#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:

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
	testing

	testing::internal

	testing::internal2

Macros
#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 []

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()"

Macro Definition 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_

private

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

Classes

Namespaces

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

Variable Documentation