Classes | Namespaces | Macros | Enumerations | Functions | Variables
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

 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 >
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 \ml\, optionally followed " "by a colon and an output file name or directory. A directory " "is indicated by a trailing pathname separator. " "Examples: \ml:filename.xml\ \ml::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: \ocalhost: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: " "\hreadsafe\(child process re-executes the test binary " "from the beginning, running only the specific death test) or " "\ast\(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

◆ EXPECT_FATAL_FAILURE

#define EXPECT_FATAL_FAILURE (   statement,
  substr 
)
Value:
do { \
class GTestExpectFatalFailureHelper {\
public:\
static void Execute() { statement; }\
};\
&gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
{\
INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
GTestExpectFatalFailureHelper::Execute();\
}\
bool AlwaysFalse()
Definition: gtest.h:7620

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

◆ EXPECT_FATAL_FAILURE_ON_ALL_THREADS

#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS (   statement,
  substr 
)
Value:
do { \
class GTestExpectFatalFailureHelper {\
public:\
static void Execute() { statement; }\
};\
&gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
{\
INTERCEPT_ALL_THREADS, &gtest_failures);\
GTestExpectFatalFailureHelper::Execute();\
}\
bool AlwaysFalse()
Definition: gtest.h:7620

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

◆ EXPECT_NONFATAL_FAILURE

#define EXPECT_NONFATAL_FAILURE (   statement,
  substr 
)

◆ EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS

#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS (   statement,
  substr 
)

◆ GTEST_HAS_GETTIMEOFDAY_

#define GTEST_HAS_GETTIMEOFDAY_   1

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

◆ GTEST_IMPL_CMP_HELPER_

#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);\
}\
}
AssertionResult AssertionSuccess()
Definition: gtest-all.cc:2452
std::string FormatForComparisonFailureMessage(const T1 &value, const T2 &)
Definition: gtest.h:18844
AssertionResult AssertionFailure(const Message &message)
Definition: gtest-all.cc:2463
long long BiggestInt
Definition: gtest.h:2756

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

◆ GTEST_IMPLEMENTATION_ [1/4]

#define GTEST_IMPLEMENTATION_   1

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

◆ GTEST_IMPLEMENTATION_ [2/4]

#define GTEST_IMPLEMENTATION_   1

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

◆ GTEST_IMPLEMENTATION_ [3/4]

#define GTEST_IMPLEMENTATION_   1

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

◆ GTEST_IMPLEMENTATION_ [4/4]

#define GTEST_IMPLEMENTATION_   1

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

◆ GTEST_INCLUDE_GTEST_GTEST_SPI_H_

#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_

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

◆ GTEST_PATH_MAX_

#define GTEST_PATH_MAX_   _POSIX_PATH_MAX

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

◆ GTEST_REPEATER_METHOD_

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

◆ GTEST_REVERSE_REPEATER_METHOD_

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

◆ GTEST_SRC_GTEST_INTERNAL_INL_H_

#define GTEST_SRC_GTEST_INTERNAL_INL_H_

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

Variable Documentation

◆ name_

std::string name_
private

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



self_test
Author(s): Kevin Watts, Brice Rebsamen , Jeremy Leibs and Blaise Gassend
autogenerated on Mon Feb 28 2022 22:19:58