gtest-all.cc File Reference

#include "gtest/gtest.h"
#include <ctype.h>
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <wchar.h>
#include <wctype.h>
#include <algorithm>
#include <iomanip>
#include <limits>
#include <ostream>
#include <sstream>
#include <vector>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <stddef.h>
#include <string.h>
#include <string>
#include <limits.h>
#include <climits>

Include dependency graph for gtest-all.cc:

Go to the source code of this file.

Classes
class	testing::internal::DefaultGlobalTestPartResultReporter
class	testing::internal::DefaultPerThreadTestPartResultReporter
class	testing::internal::GTestFlagSaver
class	testing::internal::OsStackTraceGetter
class	testing::internal::OsStackTraceGetterInterface
class	testing::internal::PrettyUnitTestResultPrinter
class	testing::ScopedFakeTestPartResultReporter
class	testing::internal::ScopedPrematureExitFile
class	testing::internal::SingleFailureChecker
class	testing::internal::TestCaseNameIs
class	testing::internal::TestEventRepeater
class	testing::internal::TestPropertyKeyIs
class	testing::internal::TestResultAccessor
struct	testing::internal::TraceInfo
class	testing::internal::UnitTestImpl
class	testing::internal::UnitTestOptions
class	testing::internal::XmlUnitTestResultPrinter
Namespaces
namespace	testing
namespace	testing::internal
namespace	testing::internal2
Defines
#define	EXPECT_FATAL_FAILURE(statement, substr)
#define	EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr)
#define	EXPECT_NONFATAL_FAILURE(statement, substr)
#define	EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr)
#define	GTEST_HAS_GETTIMEOFDAY_   1
#define	GTEST_IMPL_CMP_HELPER_(op_name, op)
#define	GTEST_IMPLEMENTATION_   1
#define	GTEST_IMPLEMENTATION_   1
#define	GTEST_IMPLEMENTATION_   1
#define	GTEST_IMPLEMENTATION_   1
#define	GTEST_INCLUDE_GTEST_GTEST_SPI_H_
#define	GTEST_PATH_MAX_   _POSIX_PATH_MAX
#define	GTEST_REPEATER_METHOD_(Name, Type)
#define	GTEST_REVERSE_REPEATER_METHOD_(Name, Type)
#define	GTEST_SRC_GTEST_INTERNAL_INL_H_
Enumerations
enum	testing::internal::CharFormat { testing::internal::kAsIs, testing::internal::kHexEscape, testing::internal::kSpecialEscape }
enum	testing::internal::GTestColor { testing::internal::COLOR_DEFAULT, testing::internal::COLOR_RED, testing::internal::COLOR_GREEN, testing::internal::COLOR_YELLOW }
Functions
bool	testing::internal::AlwaysTrue ()
std::string	testing::internal::AppendUserMessage (const std::string &gtest_msg, const Message &user_msg)
template<int kSize>
std::vector< std::string >	testing::ArrayAsVector (const char *const (&array)[kSize])
AssertionResult	testing::AssertionFailure ()
AssertionResult	testing::AssertionFailure (const Message &message)
AssertionResult	testing::AssertionSuccess ()
bool	testing::internal::BoolFromGTestEnv (const char *flag, bool default_value)
UInt32	testing::internal::ChopLowBits (UInt32 *bits, int n)
AssertionResult	testing::internal::CmpHelperEQ (const char *expected_expression, const char *actual_expression, BiggestInt expected, BiggestInt actual)
AssertionResult	testing::internal::CmpHelperSTRCASEEQ (const char *expected_expression, const char *actual_expression, const char *expected, const char *actual)
AssertionResult	testing::internal::CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
AssertionResult	testing::internal::CmpHelperSTREQ (const char *expected_expression, const char *actual_expression, const char *expected, const char *actual)
AssertionResult	testing::internal::CmpHelperSTREQ (const char *expected_expression, const char *actual_expression, const wchar_t *expected, const wchar_t *actual)
AssertionResult	testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
AssertionResult	testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
GTEST_API_ std::string	testing::internal::CodePointToUtf8 (UInt32 code_point)
void	testing::internal::ColoredPrintf (GTestColor color, const char *fmt,...)
template<class Container , typename Predicate >
int	testing::internal::CountIf (const Container &c, Predicate predicate)
UInt32	testing::internal::CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)
template<typename T >
static void	testing::internal::Delete (T *x)
AssertionResult	testing::DoubleLE (const char *expr1, const char *expr2, double val1, double val2)
AssertionResult	testing::internal::DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
AssertionResult	testing::internal::EqFailure (const char *expected_expression, const char *actual_expression, const std::string &expected_value, const std::string &actual_value, bool ignoring_case)
static std::string	testing::internal::FlagToEnvVar (const char *flag)
template<typename RawType >
AssertionResult	testing::internal::FloatingPointLE (const char *expr1, const char *expr2, RawType val1, RawType val2)
AssertionResult	testing::FloatLE (const char *expr1, const char *expr2, float val1, float val2)
template<class Container , typename Functor >
void	testing::internal::ForEach (const Container &c, Functor functor)
GTEST_API_::std::string	testing::internal::FormatCompilerIndependentFileLocation (const char *file, int line)
static std::string	testing::FormatCountableNoun (int count, const char *singular_form, const char *plural_form)
GTEST_API_ std::string	testing::internal::FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)
GTEST_API_::std::string	testing::internal::FormatFileLocation (const char *file, int line)
static std::string	testing::FormatTestCaseCount (int test_case_count)
static std::string	testing::FormatTestCount (int test_count)
GTEST_API_ std::string	testing::internal::FormatTimeInMillisAsSeconds (TimeInMillis ms)
static std::string	testing::FormatWordList (const std::vector< std::string > &words)
const char *	testing::internal::GetAnsiColorCode (GTestColor color)
std::string	testing::internal::GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
GTEST_API_ FilePath	testing::internal::GetCurrentExecutableName ()
std::string	testing::internal::GetCurrentOsStackTraceExceptTop (UnitTest *, int skip_count)
static const char *	testing::GetDefaultFilter ()
template<typename E >
E	testing::internal::GetElementOr (const std::vector< E > &v, int i, E default_value)
int	testing::internal::GetNextRandomSeed (int seed)
int	testing::internal::GetRandomSeedFromFlag (Int32 random_seed_flag)
static std::vector< std::string >	testing::GetReservedAttributesForElement (const std::string &xml_element)
TypeId	testing::internal::GetTestTypeId ()
size_t	testing::internal::GetThreadCount ()
GTEST_API_ TimeInMillis	testing::internal::GetTimeInMillis ()
UnitTestImpl *	testing::internal::GetUnitTestImpl ()
	testing::GTEST_DECLARE_bool_ (death_test_use_fork)
	testing::GTEST_DEFINE_bool_ (also_run_disabled_tests, internal::BoolFromGTestEnv("also_run_disabled_tests", false),"Run disabled tests too, in addition to the tests normally being run.")
	testing::GTEST_DEFINE_bool_ (break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),"True iff a failed assertion should be a debugger break-point.")
	testing::GTEST_DEFINE_bool_ (catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true),"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures.")
	testing::GTEST_DEFINE_bool_ (list_tests, false,"List all tests without running them.")
	testing::GTEST_DEFINE_bool_ (print_time, internal::BoolFromGTestEnv("print_time", true),"True iff "GTEST_NAME_" should display elapsed time in text output.")
	testing::GTEST_DEFINE_bool_ (show_internal_stack_frames, false,"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces.")
	testing::GTEST_DEFINE_bool_ (shuffle, internal::BoolFromGTestEnv("shuffle", false),"True iff "GTEST_NAME_" should randomize tests' order on every run.")
	testing::GTEST_DEFINE_bool_ (throw_on_failure, internal::BoolFromGTestEnv("throw_on_failure", false),"When this flag is specified, a failed assertion will throw an exception ""if exceptions are enabled or exit the program with a non-zero code ""otherwise.")
	testing::GTEST_DEFINE_bool_ (death_test_use_fork, internal::BoolFromGTestEnv("death_test_use_fork", false),"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is fixed, this flag will ""most likely be removed.")
	testing::GTEST_DEFINE_int32_ (random_seed, internal::Int32FromGTestEnv("random_seed", 0),"Random number seed to use when shuffling test orders. Must be in range ""[1, 99999], or 0 to use a seed based on the current time.")
	testing::GTEST_DEFINE_int32_ (repeat, internal::Int32FromGTestEnv("repeat", 1),"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests.")
	testing::GTEST_DEFINE_int32_ (stack_trace_depth, internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through 100, inclusive.")
GTEST_API_	testing::internal::GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)
	testing::GTEST_DEFINE_string_ (color, internal::StringFromGTestEnv("color","auto"),"Whether to use colors in the output. Valid values: yes, no, ""and auto. 'auto' means to use colors if the output is ""being sent to a terminal and the TERM environment variable ""is set to a terminal type that supports colors.")
	testing::GTEST_DEFINE_string_ (filter, internal::StringFromGTestEnv("filter", GetDefaultFilter()),"A colon-separated list of glob (not regex) patterns ""for filtering the tests to run, optionally followed by a ""'-' and a : separated list of negative patterns (tests to ""exclude). A test is run if it matches one of the positive ""patterns and does not match any of the negative patterns.")
	testing::GTEST_DEFINE_string_ (output, internal::StringFromGTestEnv("output",""),"A format (currently must be \"xml\"), optionally followed ""by a colon and an output file name or directory. A directory ""is indicated by a trailing pathname separator. ""Examples: \"xml:filename.xml\", \"xml::directoryname/\". ""If a directory is specified, output files will be created ""within that directory, with file-names based on the test ""executable's name and, if necessary, made unique by adding ""digits.")
	testing::GTEST_DEFINE_string_ (stream_result_to, internal::StringFromGTestEnv("stream_result_to",""),"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux.")
	testing::GTEST_DEFINE_string_ (death_test_style, internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking).")
	testing::internal::GTEST_DEFINE_string_ (internal_run_death_test,"","Indicates the file, line number, temporal index of ""the single death test to run, and a file descriptor to ""which a success code may be sent, all separated by ""the '|' characters. This flag is specified if and only if the current ""process is a sub-process launched for running a thread-safe ""death test. FOR INTERNAL USE ONLY.")
static bool	testing::internal::GTestIsInitialized ()
template<class T , typename Result >
Result	testing::internal::HandleExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
template<class T , typename Result >
Result	testing::internal::HandleSehExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
static bool	testing::internal::HasGoogleTestFlagPrefix (const char *str)
AssertionResult	testing::internal::HasOneFailure (const char *, const char *, const char *, const TestPartResultArray &results, TestPartResult::Type type, const string &substr)
void	testing::InitGoogleTest (int *argc, char **argv)
void	testing::InitGoogleTest (int *argc, wchar_t **argv)
template<typename CharType >
void	testing::internal::InitGoogleTestImpl (int *argc, CharType **argv)
GTEST_API_ Int32	testing::internal::Int32FromEnvOrDie (const char *env_var, Int32 default_val)
Int32	testing::internal::Int32FromGTestEnv (const char *flag, Int32 default_value)
AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
static bool	testing::internal::IsPathSeparator (char c)
bool	testing::internal::IsPrintableAscii (wchar_t c)
AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
bool	testing::internal::IsTrue (bool condition)
bool	testing::internal::IsUtf16SurrogatePair (wchar_t first, wchar_t second)
TestInfo *	testing::internal::MakeAndRegisterTestInfo (const char *test_case_name, const char *name, const char *type_param, const char *value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)
std::ostream &	testing::operator<< (std::ostream &os, const TestPartResult &result)
bool	testing::internal::ParseBoolFlag (const char *str, const char *flag, bool *value)
const char *	testing::internal::ParseFlagValue (const char *str, const char *flag, bool def_optional)
GTEST_API_ void	testing::internal::ParseGoogleTestFlagsOnly (int *argc, char **argv)
GTEST_API_ void	testing::internal::ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)
template<typename CharType >
void	testing::internal::ParseGoogleTestFlagsOnlyImpl (int *argc, CharType **argv)
bool	testing::internal::ParseInt32 (const Message &src_text, const char *str, Int32 *value)
GTEST_API_ bool	testing::internal::ParseInt32Flag (const char *str, const char *flag, Int32 *value)
bool	testing::internal::ParseStringFlag (const char *str, const char *flag, std::string *value)
template<typename UnsignedChar , typename Char >
static CharFormat	testing::internal::PrintAsCharLiteralTo (Char c, ostream *os)
static CharFormat	testing::internal::PrintAsStringLiteralTo (wchar_t c, ostream *os)
static CharFormat	testing::internal::PrintAsStringLiteralTo (char c, ostream *os)
void	testing::internal2::PrintBytesInObjectTo (const unsigned char *obj_bytes, size_t count, ostream *os)
template<typename UnsignedChar , typename Char >
void	testing::internal::PrintCharAndCodeTo (Char c, ostream *os)
template<typename CharType >
static void	testing::internal::PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
static void	testing::internal::PrintColorEncoded (const char *str)
void	testing::internal::PrintFullTestCommentIfPresent (const TestInfo &test_info)
static void	testing::internal::PrintOnOneLine (const char *str, int max_length)
void	testing::internal::PrintStringTo (const ::std::string &s, ostream *os)
static void	testing::internal::PrintTestPartResult (const TestPartResult &test_part_result)
static std::string	testing::internal::PrintTestPartResultToString (const TestPartResult &test_part_result)
void	testing::internal::PrintTo (unsigned char c,::std::ostream *os)
void	testing::internal::PrintTo (signed char c,::std::ostream *os)
void	testing::internal::PrintTo (wchar_t wc, ostream *os)
void	testing::internal::PrintTo (const char *s, ostream *os)
void	testing::internal::PrintTo (const wchar_t *s, ostream *os)
void	testing::internal::ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)
static void	testing::internal::SetUpEnvironment (Environment *env)
static bool	testing::internal::ShouldRunTestCase (const TestCase *test_case)
GTEST_API_ bool	testing::internal::ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)
GTEST_API_ bool	testing::internal::ShouldShard (const char *total_shards_str, const char *shard_index_str, bool in_subprocess_for_death_test)
GTEST_API_ bool	testing::internal::ShouldUseColor (bool stdout_is_tty)
template<typename E >
void	testing::internal::Shuffle (internal::Random *random, std::vector< E > *v)
template<typename E >
void	testing::internal::ShuffleRange (internal::Random *random, int begin, int end, std::vector< E > *v)
bool	testing::internal::SkipPrefix (const char *prefix, const char **pstr)
const char *	testing::internal::StringFromGTestEnv (const char *flag, const char *default_value)
std::string	testing::internal::StringStreamToString (::std::stringstream *ss)
static int	testing::internal::SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)
static void	testing::internal::TearDownEnvironment (Environment *env)
static bool	testing::internal::TestCaseFailed (const TestCase *test_case)
static bool	testing::internal::TestCasePassed (const TestCase *test_case)
static bool	testing::TestPartFatallyFailed (const TestPartResult &result)
static bool	testing::TestPartNonfatallyFailed (const TestPartResult &result)
static const char *	testing::TestPartResultTypeToString (TestPartResult::Type type)
void	testing::internal::UniversalPrintArray (const char *begin, size_t len, ostream *os)
void	testing::internal::UniversalPrintArray (const wchar_t *begin, size_t len, ostream *os)
template<typename CharType >
static void	testing::internal::UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
bool	testing::ValidateTestPropertyName (const std::string &property_name, const std::vector< std::string > &reserved_names)
GTEST_API_ std::string	testing::internal::WideStringToUtf8 (const wchar_t *str, int num_chars)
void	testing::internal::WriteToShardStatusFileIfNeeded ()
Variables
std::string	testing::internal::g_executable_path
GTEST_API_ bool	testing::internal::g_help_flag = false
GTEST_API_ int	testing::internal::g_init_gtest_count = 0
class testing::internal::GTestFlagSaver	testing::internal::GTEST_ATTRIBUTE_UNUSED_
const char	testing::internal::kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"
const char	testing::internal::kBreakOnFailureFlag [] = "break_on_failure"
const char	testing::internal::kCatchExceptionsFlag [] = "catch_exceptions"
static const char	testing::internal::kColorEncodedHelpMessage [] = ">@D.\n"
const char	testing::internal::kColorFlag [] = "color"
const char	testing::internal::kCurrentDirectoryString [] = "./"
static const char	testing::kDeathTestCaseFilter [] = "*DeathTest:*DeathTest/*"
static const char	testing::kDefaultDeathTestStyle [] = "fast"
static const char	testing::kDefaultOutputFile [] = "test_detail.xml"
static const char	testing::kDisableTestFilter [] = "DISABLED_*:*/DISABLED_*"
const char	testing::internal::kFilterFlag [] = "filter"
const char	testing::internal::kListTestsFlag [] = "list_tests"
const UInt32	testing::internal::kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1
const UInt32	testing::internal::kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1
const UInt32	testing::internal::kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1
const UInt32	testing::internal::kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1
const int	testing::internal::kMaxRandomSeed = 99999
const char	testing::internal::kOutputFlag [] = "output"
const char	testing::internal::kPathSeparator = '/'
const char	testing::internal::kPathSeparatorString [] = "/"
const char	testing::internal::kPrintTimeFlag [] = "print_time"
const char	testing::internal::kRandomSeedFlag [] = "random_seed"
const char	testing::internal::kRepeatFlag [] = "repeat"
static const char *const	testing::kReservedTestCaseAttributes []
static const char *const	testing::kReservedTestSuiteAttributes []
static const char *const	testing::kReservedTestSuitesAttributes []
const char	testing::internal::kShuffleFlag [] = "shuffle"
const char	testing::internal::kStackTraceDepthFlag [] = "stack_trace_depth"
const char	testing::internal::kStackTraceMarker [] = "\nStack trace:\n"
const int	testing::internal::kStdErrFileno = STDERR_FILENO
const int	testing::internal::kStdOutFileno = STDOUT_FILENO
const char	testing::internal::kStreamResultToFlag [] = "stream_result_to"
static const char	testing::kTestShardIndex [] = "GTEST_SHARD_INDEX"
static const char	testing::kTestShardStatusFile [] = "GTEST_SHARD_STATUS_FILE"
static const char	testing::kTestTotalShards [] = "GTEST_TOTAL_SHARDS"
GTEST_API_ const TypeId	testing::internal::kTestTypeIdInGoogleTest = GetTestTypeId()
const char	testing::internal::kThrowOnFailureFlag [] = "throw_on_failure"
static const char	testing::internal::kTypeParamLabel [] = "TypeParam"
static const char	testing::kUniversalFilter [] = "*"
const char	testing::internal::kUnknownFile [] = "unknown file"
static const char	testing::internal::kValueParamLabel [] = "GetParam()"

---

Define Documentation

#define EXPECT_FATAL_FAILURE	(		statement,
			substr
	)

Value:

do { \
    class GTestExpectFatalFailureHelper {\
     public:\
      static void Execute() { statement; }\
    };\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      GTestExpectFatalFailureHelper::Execute();\
    }\
  } while (::testing::internal::AlwaysFalse())

Definition at line 211 of file gtest-all.cc.

#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS	(		statement,
			substr
	)

Value:

do { \
    class GTestExpectFatalFailureHelper {\
     public:\
      static void Execute() { statement; }\
    };\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ALL_THREADS, &gtest_failures);\
      GTestExpectFatalFailureHelper::Execute();\
    }\
  } while (::testing::internal::AlwaysFalse())

Definition at line 228 of file gtest-all.cc.

#define EXPECT_NONFATAL_FAILURE	(		statement,
			substr
	)

Value:

do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
        (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
    }\
  } while (::testing::internal::AlwaysFalse())

Definition at line 277 of file gtest-all.cc.

#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS	(		statement,
			substr
	)

Value:

do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
        (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
          &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
    }\
  } while (::testing::internal::AlwaysFalse())

Definition at line 291 of file gtest-all.cc.

#define GTEST_HAS_GETTIMEOFDAY_   1

Definition at line 381 of file gtest-all.cc.

#define GTEST_IMPL_CMP_HELPER_	(		op_name,
			op
	)

Value:

AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                   BiggestInt val1, BiggestInt val2) {\
  if (val1 op val2) {\
    return AssertionSuccess();\
  } else {\
    return AssertionFailure() \
        << "Expected: (" << expr1 << ") " #op " (" << expr2\
        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
  }\
}

Definition at line 2616 of file gtest-all.cc.

#define GTEST_IMPLEMENTATION_   1

Definition at line 9416 of file gtest-all.cc.

#define GTEST_IMPLEMENTATION_   1

Definition at line 9416 of file gtest-all.cc.

#define GTEST_IMPLEMENTATION_   1

Definition at line 9416 of file gtest-all.cc.

#define GTEST_IMPLEMENTATION_   1

Definition at line 9416 of file gtest-all.cc.

#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_

Definition at line 110 of file gtest-all.cc.

#define GTEST_PATH_MAX_   _POSIX_PATH_MAX

Definition at line 7893 of file gtest-all.cc.

#define GTEST_REPEATER_METHOD_	(		Name,
			Type
	)

Value:

void TestEventRepeater::Name(const Type& parameter) { \
  if (forwarding_enabled_) { \
    for (size_t i = 0; i < listeners_.size(); i++) { \
      listeners_[i]->Name(parameter); \
    } \
  } \
}

Definition at line 4441 of file gtest-all.cc.

#define GTEST_REVERSE_REPEATER_METHOD_	(		Name,
			Type
	)

Value:

void TestEventRepeater::Name(const Type& parameter) { \
  if (forwarding_enabled_) { \
    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
      listeners_[i]->Name(parameter); \
    } \
  } \
}

Definition at line 4451 of file gtest-all.cc.

#define GTEST_SRC_GTEST_INTERNAL_INL_H_

Definition at line 442 of file gtest-all.cc.

---

Variable Documentation

std::string name_

Definition at line 3761 of file gtest-all.cc.