/Unittests/googletest/include/gtest/internal/gtest-port.h
http://unladen-swallow.googlecode.com/ · C++ Header · 1084 lines · 500 code · 158 blank · 426 comment · 46 complexity · ad17d570d68a1a18b2752989f9c3bb85 MD5 · raw file
- // Copyright 2005, Google Inc.
- // All rights reserved.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // * Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- // * Redistributions in binary form must reproduce the above
- // copyright notice, this list of conditions and the following disclaimer
- // in the documentation and/or other materials provided with the
- // distribution.
- // * Neither the name of Google Inc. nor the names of its
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- //
- // Authors: wan@google.com (Zhanyong Wan)
- //
- // Low-level types and utilities for porting Google Test to various
- // platforms. They are subject to change without notice. DO NOT USE
- // THEM IN USER CODE.
- #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
- #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
- // The user can define the following macros in the build script to
- // control Google Test's behavior. If the user doesn't define a macro
- // in this list, Google Test will define it.
- //
- // GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2)
- // is/isn't available.
- // GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string
- // is/isn't available (some systems define
- // ::string, which is different to std::string).
- // GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
- // is/isn't available (some systems define
- // ::wstring, which is different to std::wstring).
- // GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h>
- // is/isn't available.
- // GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't
- // enabled.
- // GTEST_HAS_STD_STRING - Define it to 1/0 to indicate that
- // std::string does/doesn't work (Google Test can
- // be used where std::string is unavailable).
- // GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that
- // std::wstring does/doesn't work (Google Test can
- // be used where std::wstring is unavailable).
- // GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple
- // is/isn't available.
- // GTEST_HAS_SEH - Define it to 1/0 to indicate whether the
- // compiler supports Microsoft's "Structured
- // Exception Handling".
- // GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google
- // Test's own tr1 tuple implementation should be
- // used. Unused when the user sets
- // GTEST_HAS_TR1_TUPLE to 0.
- // This header defines the following utilities:
- //
- // Macros indicating the current platform (defined to 1 if compiled on
- // the given platform; otherwise undefined):
- // GTEST_OS_CYGWIN - Cygwin
- // GTEST_OS_LINUX - Linux
- // GTEST_OS_MAC - Mac OS X
- // GTEST_OS_SOLARIS - Sun Solaris
- // GTEST_OS_SYMBIAN - Symbian
- // GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile)
- // GTEST_OS_WINDOWS_DESKTOP - Windows Desktop
- // GTEST_OS_WINDOWS_MINGW - MinGW
- // GTEST_OS_WINODWS_MOBILE - Windows Mobile
- // GTEST_OS_ZOS - z/OS
- //
- // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
- // most stable support. Since core members of the Google Test project
- // don't have access to other platforms, support for them may be less
- // stable. If you notice any problems on your platform, please notify
- // googletestframework@googlegroups.com (patches for fixing them are
- // even more welcome!).
- //
- // Note that it is possible that none of the GTEST_OS_* macros are defined.
- //
- // Macros indicating available Google Test features (defined to 1 if
- // the corresponding feature is supported; otherwise undefined):
- // GTEST_HAS_COMBINE - the Combine() function (for value-parameterized
- // tests)
- // GTEST_HAS_DEATH_TEST - death tests
- // GTEST_HAS_PARAM_TEST - value-parameterized tests
- // GTEST_HAS_TYPED_TEST - typed tests
- // GTEST_HAS_TYPED_TEST_P - type-parameterized tests
- // GTEST_USES_POSIX_RE - enhanced POSIX regex is used.
- // GTEST_USES_SIMPLE_RE - our own simple regex is used;
- // the above two are mutually exclusive.
- //
- // Macros for basic C++ coding:
- // GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
- // GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a
- // variable don't have to be used.
- // GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
- // GTEST_MUST_USE_RESULT_ - declares that a function's result must be used.
- //
- // Synchronization:
- // Mutex, MutexLock, ThreadLocal, GetThreadCount()
- // - synchronization primitives.
- // GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
- // synchronization primitives have real implementations
- // and Google Test is thread-safe; or 0 otherwise.
- //
- // Template meta programming:
- // is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only.
- //
- // Smart pointers:
- // scoped_ptr - as in TR2.
- //
- // Regular expressions:
- // RE - a simple regular expression class using the POSIX
- // Extended Regular Expression syntax. Not available on
- // Windows.
- //
- // Logging:
- // GTEST_LOG_() - logs messages at the specified severity level.
- // LogToStderr() - directs all log messages to stderr.
- // FlushInfoLog() - flushes informational log messages.
- //
- // Stderr capturing:
- // CaptureStderr() - starts capturing stderr.
- // GetCapturedStderr() - stops capturing stderr and returns the captured
- // string.
- //
- // Integer types:
- // TypeWithSize - maps an integer to a int type.
- // Int32, UInt32, Int64, UInt64, TimeInMillis
- // - integers of known sizes.
- // BiggestInt - the biggest signed integer type.
- //
- // Command-line utilities:
- // GTEST_FLAG() - references a flag.
- // GTEST_DECLARE_*() - declares a flag.
- // GTEST_DEFINE_*() - defines a flag.
- // GetArgvs() - returns the command line as a vector of strings.
- //
- // Environment variable utilities:
- // GetEnv() - gets the value of an environment variable.
- // BoolFromGTestEnv() - parses a bool environment variable.
- // Int32FromGTestEnv() - parses an Int32 environment variable.
- // StringFromGTestEnv() - parses a string environment variable.
- #include <stddef.h> // For ptrdiff_t
- #include <stdlib.h>
- #include <stdio.h>
- #include <string.h>
- #ifndef _WIN32_WCE
- #include <sys/stat.h>
- #endif // !_WIN32_WCE
- #include <iostream> // NOLINT
- #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
- #define GTEST_FLAG_PREFIX_ "gtest_"
- #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
- #define GTEST_NAME_ "Google Test"
- #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
- // Determines the version of gcc that is used to compile this.
- #ifdef __GNUC__
- // 40302 means version 4.3.2.
- #define GTEST_GCC_VER_ \
- (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
- #endif // __GNUC__
- // Determines the platform on which Google Test is compiled.
- #ifdef __CYGWIN__
- #define GTEST_OS_CYGWIN 1
- #elif defined __SYMBIAN32__
- #define GTEST_OS_SYMBIAN 1
- #elif defined _WIN32
- #define GTEST_OS_WINDOWS 1
- #ifdef _WIN32_WCE
- #define GTEST_OS_WINDOWS_MOBILE 1
- #elif defined(__MINGW__) || defined(__MINGW32__)
- #define GTEST_OS_WINDOWS_MINGW 1
- #else
- #define GTEST_OS_WINDOWS_DESKTOP 1
- #endif // _WIN32_WCE
- #elif defined __APPLE__
- #define GTEST_OS_MAC 1
- #elif defined __linux__
- #define GTEST_OS_LINUX 1
- #elif defined __MVS__
- #define GTEST_OS_ZOS 1
- #elif defined(__sun) && defined(__SVR4)
- #define GTEST_OS_SOLARIS 1
- #endif // __CYGWIN__
- #if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \
- GTEST_OS_SOLARIS
- // On some platforms, <regex.h> needs someone to define size_t, and
- // won't compile otherwise. We can #include it here as we already
- // included <stdlib.h>, which is guaranteed to define size_t through
- // <stddef.h>.
- #include <regex.h> // NOLINT
- #include <strings.h> // NOLINT
- #include <sys/types.h> // NOLINT
- #include <unistd.h> // NOLINT
- #define GTEST_USES_POSIX_RE 1
- #elif GTEST_OS_WINDOWS
- #if !GTEST_OS_WINDOWS_MOBILE
- #include <direct.h> // NOLINT
- #include <io.h> // NOLINT
- #endif
- // <regex.h> is not available on Windows. Use our own simple regex
- // implementation instead.
- #define GTEST_USES_SIMPLE_RE 1
- #else
- // <regex.h> may not be available on this platform. Use our own
- // simple regex implementation instead.
- #define GTEST_USES_SIMPLE_RE 1
- #endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC ||
- // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS
- // Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0
- // otherwise.
- #if defined(_MSC_VER) || defined(__BORLANDC__)
- // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
- // macro to enable exceptions, so we'll do the same.
- // Assumes that exceptions are enabled by default.
- #ifndef _HAS_EXCEPTIONS
- #define _HAS_EXCEPTIONS 1
- #endif // _HAS_EXCEPTIONS
- #define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
- #else // The compiler is not MSVC or C++Builder.
- // gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. For
- // other compilers, we assume exceptions are disabled to be
- // conservative.
- #if defined(__GNUC__) && __EXCEPTIONS
- #define GTEST_HAS_EXCEPTIONS 1
- #else
- #define GTEST_HAS_EXCEPTIONS 0
- #endif // defined(__GNUC__) && __EXCEPTIONS
- #endif // defined(_MSC_VER) || defined(__BORLANDC__)
- // Determines whether ::std::string and ::string are available.
- #ifndef GTEST_HAS_STD_STRING
- // The user didn't tell us whether ::std::string is available, so we
- // need to figure it out. The only environment that we know
- // ::std::string is not available is MSVC 7.1 or lower with exceptions
- // disabled.
- #if defined(_MSC_VER) && (_MSC_VER < 1400) && !GTEST_HAS_EXCEPTIONS
- #define GTEST_HAS_STD_STRING 0
- #else
- #define GTEST_HAS_STD_STRING 1
- #endif
- #endif // GTEST_HAS_STD_STRING
- #ifndef GTEST_HAS_GLOBAL_STRING
- // The user didn't tell us whether ::string is available, so we need
- // to figure it out.
- #define GTEST_HAS_GLOBAL_STRING 0
- #endif // GTEST_HAS_GLOBAL_STRING
- #ifndef GTEST_HAS_STD_WSTRING
- // The user didn't tell us whether ::std::wstring is available, so we need
- // to figure it out.
- // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
- // is available.
- #if GTEST_OS_CYGWIN || GTEST_OS_SOLARIS
- // Cygwin 1.5 and below doesn't support ::std::wstring.
- // Cygwin 1.7 might add wstring support; this should be updated when clear.
- // Solaris' libc++ doesn't support it either.
- #define GTEST_HAS_STD_WSTRING 0
- #else
- #define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING
- #endif // GTEST_OS_CYGWIN || GTEST_OS_SOLARIS
- #endif // GTEST_HAS_STD_WSTRING
- #ifndef GTEST_HAS_GLOBAL_WSTRING
- // The user didn't tell us whether ::wstring is available, so we need
- // to figure it out.
- #define GTEST_HAS_GLOBAL_WSTRING \
- (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
- #endif // GTEST_HAS_GLOBAL_WSTRING
- #if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \
- GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
- #include <string> // NOLINT
- #endif // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING ||
- // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
- #if GTEST_HAS_STD_STRING
- #include <sstream> // NOLINT
- #else
- #include <strstream> // NOLINT
- #endif // GTEST_HAS_STD_STRING
- // Determines whether RTTI is available.
- #ifndef GTEST_HAS_RTTI
- // The user didn't tell us whether RTTI is enabled, so we need to
- // figure it out.
- #ifdef _MSC_VER
- #ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled.
- #define GTEST_HAS_RTTI 1
- #else
- #define GTEST_HAS_RTTI 0
- #endif // _CPPRTTI
- #elif defined(__GNUC__)
- // Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
- #if GTEST_GCC_VER_ >= 40302
- #ifdef __GXX_RTTI
- #define GTEST_HAS_RTTI 1
- #else
- #define GTEST_HAS_RTTI 0
- #endif // __GXX_RTTI
- #else
- // For gcc versions smaller than 4.3.2, we assume RTTI is enabled.
- #define GTEST_HAS_RTTI 1
- #endif // GTEST_GCC_VER >= 40302
- #else
- // Unknown compiler - assume RTTI is enabled.
- #define GTEST_HAS_RTTI 1
- #endif // _MSC_VER
- #endif // GTEST_HAS_RTTI
- // Determines whether <pthread.h> is available.
- #ifndef GTEST_HAS_PTHREAD
- // The user didn't tell us, so we need to figure it out.
- #define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC)
- #endif // GTEST_HAS_PTHREAD
- // Determines whether Google Test can use tr1/tuple. You can define
- // this macro to 0 to prevent Google Test from using tuple (any
- // feature depending on tuple with be disabled in this mode).
- #ifndef GTEST_HAS_TR1_TUPLE
- // The user didn't tell us not to do it, so we assume it's OK.
- #define GTEST_HAS_TR1_TUPLE 1
- #endif // GTEST_HAS_TR1_TUPLE
- // Determines whether Google Test's own tr1 tuple implementation
- // should be used.
- #ifndef GTEST_USE_OWN_TR1_TUPLE
- // The user didn't tell us, so we need to figure it out.
- // We use our own tr1 tuple if we aren't sure the user has an
- // implementation of it already. At this time, GCC 4.0.0+ is the only
- // mainstream compiler that comes with a TR1 tuple implementation.
- // MSVC 2008 (9.0) provides TR1 tuple in a 323 MB Feature Pack
- // download, which we cannot assume the user has. MSVC 2010 isn't
- // released yet.
- #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
- #define GTEST_USE_OWN_TR1_TUPLE 0
- #else
- #define GTEST_USE_OWN_TR1_TUPLE 1
- #endif // defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
- #endif // GTEST_USE_OWN_TR1_TUPLE
- // To avoid conditional compilation everywhere, we make it
- // gtest-port.h's responsibility to #include the header implementing
- // tr1/tuple.
- #if GTEST_HAS_TR1_TUPLE
- #if GTEST_USE_OWN_TR1_TUPLE
- #include <gtest/internal/gtest-tuple.h>
- #elif GTEST_OS_SYMBIAN
- // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
- // use STLport's tuple implementation, which unfortunately doesn't
- // work as the copy of STLport distributed with Symbian is incomplete.
- // By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
- // use its own tuple implementation.
- #ifdef BOOST_HAS_TR1_TUPLE
- #undef BOOST_HAS_TR1_TUPLE
- #endif // BOOST_HAS_TR1_TUPLE
- // This prevents <boost/tr1/detail/config.hpp>, which defines
- // BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
- #define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
- #include <tuple>
- #elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
- // GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does
- // not conform to the TR1 spec, which requires the header to be <tuple>.
- #if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
- // Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
- // which is #included by <tr1/tuple>, to not compile when RTTI is
- // disabled. _TR1_FUNCTIONAL is the header guard for
- // <tr1/functional>. Hence the following #define is a hack to prevent
- // <tr1/functional> from being included.
- #define _TR1_FUNCTIONAL 1
- #include <tr1/tuple>
- #undef _TR1_FUNCTIONAL // Allows the user to #include
- // <tr1/functional> if he chooses to.
- #else
- #include <tr1/tuple>
- #endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
- #else
- // If the compiler is not GCC 4.0+, we assume the user is using a
- // spec-conforming TR1 implementation.
- #include <tuple>
- #endif // GTEST_USE_OWN_TR1_TUPLE
- #endif // GTEST_HAS_TR1_TUPLE
- // Determines whether clone(2) is supported.
- // Usually it will only be available on Linux, excluding
- // Linux on the Itanium architecture.
- // Also see http://linux.die.net/man/2/clone.
- #ifndef GTEST_HAS_CLONE
- // The user didn't tell us, so we need to figure it out.
- #if GTEST_OS_LINUX && !defined(__ia64__)
- #define GTEST_HAS_CLONE 1
- #else
- #define GTEST_HAS_CLONE 0
- #endif // GTEST_OS_LINUX && !defined(__ia64__)
- #endif // GTEST_HAS_CLONE
- // Determines whether to support death tests.
- // Google Test does not support death tests for VC 7.1 and earlier for
- // these reasons:
- // 1. std::vector does not build in VC 7.1 when exceptions are disabled.
- // 2. std::string does not build in VC 7.1 when exceptions are disabled
- // (this is covered by GTEST_HAS_STD_STRING guard).
- // 3. abort() in a VC 7.1 application compiled as GUI in debug config
- // pops up a dialog window that cannot be suppressed programmatically.
- #if GTEST_HAS_STD_STRING && \
- (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || \
- (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW)
- #define GTEST_HAS_DEATH_TEST 1
- #include <vector> // NOLINT
- #endif
- // Determines whether to support value-parameterized tests.
- #if defined(__GNUC__) || (_MSC_VER >= 1400)
- // TODO(vladl@google.com): get the implementation rid of vector and list
- // to compile on MSVC 7.1.
- #define GTEST_HAS_PARAM_TEST 1
- #endif // defined(__GNUC__) || (_MSC_VER >= 1400)
- // Determines whether to support type-driven tests.
- // Typed tests need <typeinfo> and variadic macros, which gcc and VC
- // 8.0+ support.
- #if defined(__GNUC__) || (_MSC_VER >= 1400)
- #define GTEST_HAS_TYPED_TEST 1
- #define GTEST_HAS_TYPED_TEST_P 1
- #endif // defined(__GNUC__) || (_MSC_VER >= 1400)
- // Determines whether to support Combine(). This only makes sense when
- // value-parameterized tests are enabled.
- #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
- #define GTEST_HAS_COMBINE 1
- #endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
- // Determines whether the system compiler uses UTF-16 for encoding wide strings.
- #define GTEST_WIDE_STRING_USES_UTF16_ \
- (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN)
- // Defines some utility macros.
- // The GNU compiler emits a warning if nested "if" statements are followed by
- // an "else" statement and braces are not used to explicitly disambiguate the
- // "else" binding. This leads to problems with code like:
- //
- // if (gate)
- // ASSERT_*(condition) << "Some message";
- //
- // The "switch (0) case 0:" idiom is used to suppress this.
- #ifdef __INTEL_COMPILER
- #define GTEST_AMBIGUOUS_ELSE_BLOCKER_
- #else
- #define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT
- #endif
- // Use this annotation at the end of a struct/class definition to
- // prevent the compiler from optimizing away instances that are never
- // used. This is useful when all interesting logic happens inside the
- // c'tor and / or d'tor. Example:
- //
- // struct Foo {
- // Foo() { ... }
- // } GTEST_ATTRIBUTE_UNUSED_;
- //
- // Also use it after a variable or parameter declaration to tell the
- // compiler the variable/parameter does not have to be used.
- #if defined(__GNUC__) && !defined(COMPILER_ICC)
- #define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
- #else
- #define GTEST_ATTRIBUTE_UNUSED_
- #endif
- // A macro to disallow the evil copy constructor and operator= functions
- // This should be used in the private: declarations for a class.
- #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
- type(const type &);\
- void operator=(const type &)
- // Tell the compiler to warn about unused return values for functions declared
- // with this macro. The macro should be used on function declarations
- // following the argument list:
- //
- // Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
- #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
- #define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
- #else
- #define GTEST_MUST_USE_RESULT_
- #endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
- // Determine whether the compiler supports Microsoft's Structured Exception
- // Handling. This is supported by several Windows compilers but generally
- // does not exist on any other system.
- #ifndef GTEST_HAS_SEH
- // The user didn't tell us, so we need to figure it out.
- #if defined(_MSC_VER) || defined(__BORLANDC__)
- // These two compilers are known to support SEH.
- #define GTEST_HAS_SEH 1
- #else
- // Assume no SEH.
- #define GTEST_HAS_SEH 0
- #endif
- #endif // GTEST_HAS_SEH
- namespace testing {
- class Message;
- namespace internal {
- class String;
- // std::strstream is deprecated. However, we have to use it on
- // Windows as std::stringstream won't compile on Windows when
- // exceptions are disabled. We use std::stringstream on other
- // platforms to avoid compiler warnings there.
- #if GTEST_HAS_STD_STRING
- typedef ::std::stringstream StrStream;
- #else
- typedef ::std::strstream StrStream;
- #endif // GTEST_HAS_STD_STRING
- // A helper for suppressing warnings on constant condition. It just
- // returns 'condition'.
- bool IsTrue(bool condition);
- // Defines scoped_ptr.
- // This implementation of scoped_ptr is PARTIAL - it only contains
- // enough stuff to satisfy Google Test's need.
- template <typename T>
- class scoped_ptr {
- public:
- explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
- ~scoped_ptr() { reset(); }
- T& operator*() const { return *ptr_; }
- T* operator->() const { return ptr_; }
- T* get() const { return ptr_; }
- T* release() {
- T* const ptr = ptr_;
- ptr_ = NULL;
- return ptr;
- }
- void reset(T* p = NULL) {
- if (p != ptr_) {
- if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
- delete ptr_;
- }
- ptr_ = p;
- }
- }
- private:
- T* ptr_;
- GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
- };
- // Defines RE.
- // A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended
- // Regular Expression syntax.
- class RE {
- public:
- // Constructs an RE from a string.
- #if GTEST_HAS_STD_STRING
- RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT
- #endif // GTEST_HAS_STD_STRING
- #if GTEST_HAS_GLOBAL_STRING
- RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT
- #endif // GTEST_HAS_GLOBAL_STRING
- RE(const char* regex) { Init(regex); } // NOLINT
- ~RE();
- // Returns the string representation of the regex.
- const char* pattern() const { return pattern_; }
- // FullMatch(str, re) returns true iff regular expression re matches
- // the entire str.
- // PartialMatch(str, re) returns true iff regular expression re
- // matches a substring of str (including str itself).
- //
- // TODO(wan@google.com): make FullMatch() and PartialMatch() work
- // when str contains NUL characters.
- #if GTEST_HAS_STD_STRING
- static bool FullMatch(const ::std::string& str, const RE& re) {
- return FullMatch(str.c_str(), re);
- }
- static bool PartialMatch(const ::std::string& str, const RE& re) {
- return PartialMatch(str.c_str(), re);
- }
- #endif // GTEST_HAS_STD_STRING
- #if GTEST_HAS_GLOBAL_STRING
- static bool FullMatch(const ::string& str, const RE& re) {
- return FullMatch(str.c_str(), re);
- }
- static bool PartialMatch(const ::string& str, const RE& re) {
- return PartialMatch(str.c_str(), re);
- }
- #endif // GTEST_HAS_GLOBAL_STRING
- static bool FullMatch(const char* str, const RE& re);
- static bool PartialMatch(const char* str, const RE& re);
- private:
- void Init(const char* regex);
- // We use a const char* instead of a string, as Google Test may be used
- // where string is not available. We also do not use Google Test's own
- // String type here, in order to simplify dependencies between the
- // files.
- const char* pattern_;
- bool is_valid_;
- #if GTEST_USES_POSIX_RE
- regex_t full_regex_; // For FullMatch().
- regex_t partial_regex_; // For PartialMatch().
- #else // GTEST_USES_SIMPLE_RE
- const char* full_pattern_; // For FullMatch();
- #endif
- GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
- };
- // Defines logging utilities:
- // GTEST_LOG_(severity) - logs messages at the specified severity level. The
- // message itself is streamed into the macro.
- // LogToStderr() - directs all log messages to stderr.
- // FlushInfoLog() - flushes informational log messages.
- enum GTestLogSeverity {
- GTEST_INFO,
- GTEST_WARNING,
- GTEST_ERROR,
- GTEST_FATAL
- };
- // Formats log entry severity, provides a stream object for streaming the
- // log message, and terminates the message with a newline when going out of
- // scope.
- class GTestLog {
- public:
- GTestLog(GTestLogSeverity severity, const char* file, int line);
- // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
- ~GTestLog();
- ::std::ostream& GetStream() { return ::std::cerr; }
- private:
- const GTestLogSeverity severity_;
- GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
- };
- #define GTEST_LOG_(severity) \
- ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
- __FILE__, __LINE__).GetStream()
- inline void LogToStderr() {}
- inline void FlushInfoLog() { fflush(NULL); }
- // Defines the stderr capturer:
- // CaptureStderr - starts capturing stderr.
- // GetCapturedStderr - stops capturing stderr and returns the captured string.
- void CaptureStderr();
- String GetCapturedStderr();
- #if GTEST_HAS_DEATH_TEST
- // A copy of all command line arguments. Set by InitGoogleTest().
- extern ::std::vector<String> g_argvs;
- // GTEST_HAS_DEATH_TEST implies we have ::std::string.
- const ::std::vector<String>& GetArgvs();
- #endif // GTEST_HAS_DEATH_TEST
- // Defines synchronization primitives.
- // A dummy implementation of synchronization primitives (mutex, lock,
- // and thread-local variable). Necessary for compiling Google Test where
- // mutex is not supported - using Google Test in multiple threads is not
- // supported on such platforms.
- class Mutex {
- public:
- Mutex() {}
- explicit Mutex(int /*unused*/) {}
- void AssertHeld() const {}
- enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 };
- };
- // We cannot call it MutexLock directly as the ctor declaration would
- // conflict with a macro named MutexLock, which is defined on some
- // platforms. Hence the typedef trick below.
- class GTestMutexLock {
- public:
- explicit GTestMutexLock(Mutex*) {} // NOLINT
- };
- typedef GTestMutexLock MutexLock;
- template <typename T>
- class ThreadLocal {
- public:
- ThreadLocal() : value_() {}
- explicit ThreadLocal(const T& value) : value_(value) {}
- T* pointer() { return &value_; }
- const T* pointer() const { return &value_; }
- const T& get() const { return value_; }
- void set(const T& value) { value_ = value; }
- private:
- T value_;
- };
- // Returns the number of threads running in the process, or 0 to indicate that
- // we cannot detect it.
- size_t GetThreadCount();
- // The above synchronization primitives have dummy implementations.
- // Therefore Google Test is not thread-safe.
- #define GTEST_IS_THREADSAFE 0
- #if defined(__SYMBIAN32__) || defined(__IBMCPP__)
- // Passing non-POD classes through ellipsis (...) crashes the ARM
- // compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to
- // instantiate a copy constructor for objects passed through ellipsis
- // (...), failing for uncopyable objects. We define this to indicate
- // the fact.
- #define GTEST_ELLIPSIS_NEEDS_COPY_ 1
- // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
- // const T& and const T* in a function template. These compilers
- // _can_ decide between class template specializations for T and T*,
- // so a tr1::type_traits-like is_pointer works.
- #define GTEST_NEEDS_IS_POINTER_ 1
- #endif // defined(__SYMBIAN32__) || defined(__IBMCPP__)
- template <bool bool_value>
- struct bool_constant {
- typedef bool_constant<bool_value> type;
- static const bool value = bool_value;
- };
- template <bool bool_value> const bool bool_constant<bool_value>::value;
- typedef bool_constant<false> false_type;
- typedef bool_constant<true> true_type;
- template <typename T>
- struct is_pointer : public false_type {};
- template <typename T>
- struct is_pointer<T*> : public true_type {};
- #if GTEST_OS_WINDOWS
- #define GTEST_PATH_SEP_ "\\"
- // The biggest signed integer type the compiler supports.
- typedef __int64 BiggestInt;
- #else
- #define GTEST_PATH_SEP_ "/"
- typedef long long BiggestInt; // NOLINT
- #endif // GTEST_OS_WINDOWS
- // The testing::internal::posix namespace holds wrappers for common
- // POSIX functions. These wrappers hide the differences between
- // Windows/MSVC and POSIX systems. Since some compilers define these
- // standard functions as macros, the wrapper cannot have the same name
- // as the wrapped function.
- namespace posix {
- // Functions with a different name on Windows.
- #if GTEST_OS_WINDOWS
- typedef struct _stat StatStruct;
- #ifdef __BORLANDC__
- inline int IsATTY(int fd) { return isatty(fd); }
- inline int StrCaseCmp(const char* s1, const char* s2) {
- return stricmp(s1, s2);
- }
- inline char* StrDup(const char* src) { return strdup(src); }
- #else // !__BORLANDC__
- #if GTEST_OS_WINDOWS_MOBILE
- inline int IsATTY(int /* fd */) { return 0; }
- #else
- inline int IsATTY(int fd) { return _isatty(fd); }
- #endif // GTEST_OS_WINDOWS_MOBILE
- inline int StrCaseCmp(const char* s1, const char* s2) {
- return _stricmp(s1, s2);
- }
- inline char* StrDup(const char* src) { return _strdup(src); }
- #endif // __BORLANDC__
- #if GTEST_OS_WINDOWS_MOBILE
- inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
- // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
- // time and thus not defined there.
- #else
- inline int FileNo(FILE* file) { return _fileno(file); }
- inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
- inline int RmDir(const char* dir) { return _rmdir(dir); }
- inline bool IsDir(const StatStruct& st) {
- return (_S_IFDIR & st.st_mode) != 0;
- }
- #endif // GTEST_OS_WINDOWS_MOBILE
- #else
- typedef struct stat StatStruct;
- inline int FileNo(FILE* file) { return fileno(file); }
- inline int IsATTY(int fd) { return isatty(fd); }
- inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
- inline int StrCaseCmp(const char* s1, const char* s2) {
- return strcasecmp(s1, s2);
- }
- inline char* StrDup(const char* src) { return strdup(src); }
- inline int RmDir(const char* dir) { return rmdir(dir); }
- inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
- #endif // GTEST_OS_WINDOWS
- // Functions deprecated by MSVC 8.0.
- #ifdef _MSC_VER
- // Temporarily disable warning 4996 (deprecated function).
- #pragma warning(push)
- #pragma warning(disable:4996)
- #endif
- inline const char* StrNCpy(char* dest, const char* src, size_t n) {
- return strncpy(dest, src, n);
- }
- // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
- // StrError() aren't needed on Windows CE at this time and thus not
- // defined there.
- #if !GTEST_OS_WINDOWS_MOBILE
- inline int ChDir(const char* dir) { return chdir(dir); }
- #endif
- inline FILE* FOpen(const char* path, const char* mode) {
- return fopen(path, mode);
- }
- #if !GTEST_OS_WINDOWS_MOBILE
- inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
- return freopen(path, mode, stream);
- }
- inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
- #endif
- inline int FClose(FILE* fp) { return fclose(fp); }
- #if !GTEST_OS_WINDOWS_MOBILE
- inline int Read(int fd, void* buf, unsigned int count) {
- return static_cast<int>(read(fd, buf, count));
- }
- inline int Write(int fd, const void* buf, unsigned int count) {
- return static_cast<int>(write(fd, buf, count));
- }
- inline int Close(int fd) { return close(fd); }
- inline const char* StrError(int errnum) { return strerror(errnum); }
- #endif
- inline const char* GetEnv(const char* name) {
- #if GTEST_OS_WINDOWS_MOBILE
- // We are on Windows CE, which has no environment variables.
- return NULL;
- #elif defined(__BORLANDC__)
- // Environment variables which we programmatically clear will be set to the
- // empty string rather than unset (NULL). Handle that case.
- const char* const env = getenv(name);
- return (env != NULL && env[0] != '\0') ? env : NULL;
- #else
- return getenv(name);
- #endif
- }
- #ifdef _MSC_VER
- #pragma warning(pop) // Restores the warning state.
- #endif
- #if GTEST_OS_WINDOWS_MOBILE
- // Windows CE has no C library. The abort() function is used in
- // several places in Google Test. This implementation provides a reasonable
- // imitation of standard behaviour.
- void Abort();
- #else
- inline void Abort() { abort(); }
- #endif // GTEST_OS_WINDOWS_MOBILE
- } // namespace posix
- // The maximum number a BiggestInt can represent. This definition
- // works no matter BiggestInt is represented in one's complement or
- // two's complement.
- //
- // We cannot rely on numeric_limits in STL, as __int64 and long long
- // are not part of standard C++ and numeric_limits doesn't need to be
- // defined for them.
- const BiggestInt kMaxBiggestInt =
- ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
- // This template class serves as a compile-time function from size to
- // type. It maps a size in bytes to a primitive type with that
- // size. e.g.
- //
- // TypeWithSize<4>::UInt
- //
- // is typedef-ed to be unsigned int (unsigned integer made up of 4
- // bytes).
- //
- // Such functionality should belong to STL, but I cannot find it
- // there.
- //
- // Google Test uses this class in the implementation of floating-point
- // comparison.
- //
- // For now it only handles UInt (unsigned int) as that's all Google Test
- // needs. Other types can be easily added in the future if need
- // arises.
- template <size_t size>
- class TypeWithSize {
- public:
- // This prevents the user from using TypeWithSize<N> with incorrect
- // values of N.
- typedef void UInt;
- };
- // The specialization for size 4.
- template <>
- class TypeWithSize<4> {
- public:
- // unsigned int has size 4 in both gcc and MSVC.
- //
- // As base/basictypes.h doesn't compile on Windows, we cannot use
- // uint32, uint64, and etc here.
- typedef int Int;
- typedef unsigned int UInt;
- };
- // The specialization for size 8.
- template <>
- class TypeWithSize<8> {
- public:
- #if GTEST_OS_WINDOWS
- typedef __int64 Int;
- typedef unsigned __int64 UInt;
- #else
- typedef long long Int; // NOLINT
- typedef unsigned long long UInt; // NOLINT
- #endif // GTEST_OS_WINDOWS
- };
- // Integer types of known sizes.
- typedef TypeWithSize<4>::Int Int32;
- typedef TypeWithSize<4>::UInt UInt32;
- typedef TypeWithSize<8>::Int Int64;
- typedef TypeWithSize<8>::UInt UInt64;
- typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds.
- // Utilities for command line flags and environment variables.
- // INTERNAL IMPLEMENTATION - DO NOT USE.
- //
- // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
- // is not satisfied.
- // Synopsys:
- // GTEST_CHECK_(boolean_condition);
- // or
- // GTEST_CHECK_(boolean_condition) << "Additional message";
- //
- // This checks the condition and if the condition is not satisfied
- // it prints message about the condition violation, including the
- // condition itself, plus additional message streamed into it, if any,
- // and then it aborts the program. It aborts the program irrespective of
- // whether it is built in the debug mode or not.
- #define GTEST_CHECK_(condition) \
- GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
- if (::testing::internal::IsTrue(condition)) \
- ; \
- else \
- GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
- // Macro for referencing flags.
- #define GTEST_FLAG(name) FLAGS_gtest_##name
- // Macros for declaring flags.
- #define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
- #define GTEST_DECLARE_int32_(name) \
- extern ::testing::internal::Int32 GTEST_FLAG(name)
- #define GTEST_DECLARE_string_(name) \
- extern ::testing::internal::String GTEST_FLAG(name)
- // Macros for defining flags.
- #define GTEST_DEFINE_bool_(name, default_val, doc) \
- bool GTEST_FLAG(name) = (default_val)
- #define GTEST_DEFINE_int32_(name, default_val, doc) \
- ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
- #define GTEST_DEFINE_string_(name, default_val, doc) \
- ::testing::internal::String GTEST_FLAG(name) = (default_val)
- // Parses 'str' for a 32-bit signed integer. If successful, writes the result
- // to *value and returns true; otherwise leaves *value unchanged and returns
- // false.
- // TODO(chandlerc): Find a better way to refactor flag and environment parsing
- // out of both gtest-port.cc and gtest.cc to avoid exporting this utility
- // function.
- bool ParseInt32(const Message& src_text, const char* str, Int32* value);
- // Parses a bool/Int32/string from the environment variable
- // corresponding to the given Google Test flag.
- bool BoolFromGTestEnv(const char* flag, bool default_val);
- Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
- const char* StringFromGTestEnv(const char* flag, const char* default_val);
- } // namespace internal
- } // namespace testing
- #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_