#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 <list>
#include <map>
#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 <fstream>
#include <cwchar>
#include "gmock/gmock.h"
#include <iostream>
#include <set>

Include dependency graph for gmock-gtest-all.cc:

Classes
class	testing::internal::CapturedStream

class	testing::internal::DefaultGlobalTestPartResultReporter

class	testing::internal::DefaultPerThreadTestPartResultReporter

class	testing::internal::GoogleTestFailureReporter

class	testing::internal::GTestFlagSaver

class	testing::internal::MaxBipartiteMatchState

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

	testing::internal::edit_distance

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, testing::internal::kAsIs, testing::internal::kHexEscape, testing::internal::kSpecialEscape, testing::internal::kAsIs, testing::internal::kHexEscape, testing::internal::kSpecialEscape, testing::internal::kAsIs, testing::internal::kHexEscape, testing::internal::kSpecialEscape, testing::internal::kAsIs, testing::internal::kHexEscape, testing::internal::kSpecialEscape, 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, testing::internal::COLOR_DEFAULT, testing::internal::COLOR_RED, testing::internal::COLOR_GREEN, testing::internal::COLOR_YELLOW, testing::internal::COLOR_DEFAULT, testing::internal::COLOR_RED, testing::internal::COLOR_GREEN, testing::internal::COLOR_YELLOW, testing::internal::COLOR_DEFAULT, testing::internal::COLOR_RED, testing::internal::COLOR_GREEN, testing::internal::COLOR_YELLOW }

Functions
GTEST_API_ bool	testing::internal::AlwaysTrue ()

GTEST_API_ Cardinality	testing::AnyNumber ()

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

GTEST_API_ Cardinality	testing::AtLeast (int n)

GTEST_API_ Cardinality	testing::AtMost (int n)

GTEST_API_ Cardinality	testing::Between (int min, int max)

bool	testing::internal::BoolFromGTestEnv (const char *flag, bool default_val)

GTEST_API_ std::vector< EditType >	testing::internal::edit_distance::CalculateOptimalEdits (const std::vector< size_t > &left, const std::vector< size_t > &right)

GTEST_API_ std::vector< EditType >	testing::internal::edit_distance::CalculateOptimalEdits (const std::vector< std::string > &left, const std::vector< std::string > &right)

GTEST_API_ void	testing::internal::CaptureStderr ()

GTEST_API_ void	testing::internal::CaptureStdout ()

void	testing::internal::CaptureStream (int fd, const char stream_name, CapturedStream *stream)

UInt32	testing::internal::ChopLowBits (UInt32 *bits, int n)

GTEST_API_ AssertionResult	testing::internal::CmpHelperEQ (const char lhs_expression, const char rhs_expression, BiggestInt lhs, BiggestInt rhs)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRCASEEQ (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRCASENE (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTREQ (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTREQ (const char s1_expression, const char s2_expression, const wchar_t s1, const wchar_t s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRNE (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRNE (const char s1_expression, const char s2_expression, const wchar_t s1, const wchar_t s2)

std::string	testing::internal::CodePointToUtf8 (UInt32 code_point)

void	testing::internal::ColoredPrintf (GTestColor color, const char *fmt,...)

GTEST_API_ std::string	testing::internal::ConvertIdentifierNameToWords (const char *id_name)

template<class Container , typename Predicate >
int	testing::internal::CountIf (const Container &c, Predicate predicate)

UInt32	testing::internal::CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)

GTEST_API_ std::string	testing::internal::edit_distance::CreateUnifiedDiff (const std::vector< std::string > &left, const std::vector< std::string > &right, size_t context=2)

template<typename T >
static void	testing::internal::Delete (T *x)

GTEST_API_ AssertionResult	testing::DoubleLE (const char expr1, const char expr2, double val1, double val2)

GTEST_API_ AssertionResult	testing::internal::DoubleNearPredFormat (const char expr1, const char expr2, const char *abs_error_expr, double val1, double val2, double abs_error)

GTEST_API_ 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)

GTEST_API_ Cardinality	testing::Exactly (int n)

GTEST_API_ ElementMatcherPairs	testing::internal::FindMaxBipartiteMatching (const MatchMatrix &g)

GTEST_API_ bool	testing::internal::FindPairing (const MatchMatrix &matrix, MatchResultListener *listener)

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)

GTEST_API_ 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)

std::string	testing::internal::FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)

GTEST_API_ ::std::string	testing::internal::FormatFileLocation (const char *file, int line)

GTEST_API_ std::string	testing::internal::FormatMatcherDescription (bool negation, const char *matcher_name, const Strings &param_values)

static std::string	testing::FormatTestCaseCount (int test_case_count)

static std::string	testing::FormatTestCount (int test_count)

std::string	testing::internal::FormatTimeInMillisAsSeconds (TimeInMillis ms)

static std::string	testing::FormatWordList (const std::vector< std::string > &words)

static const char *	testing::internal::GetAnsiColorCode (GTestColor color)

GTEST_API_ std::vector< std::string >	testing::internal::GetArgvs ()

GTEST_API_ 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_ std::string	testing::internal::GetCapturedStderr ()

GTEST_API_ std::string	testing::internal::GetCapturedStdout ()

std::string	testing::internal::GetCapturedStream (CapturedStream **captured_stream)

FilePath	testing::internal::GetCurrentExecutableName ()

GTEST_API_ std::string	testing::internal::GetCurrentOsStackTraceExceptTop (UnitTest *unit_test, 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)

GTEST_API_ FailureReporterInterface *	testing::internal::GetFailureReporter ()

GTEST_API_ size_t	testing::internal::GetFileSize (FILE *file)

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)

GTEST_API_ TypeId	testing::internal::GetTestTypeId ()

GTEST_API_ size_t	testing::internal::GetThreadCount ()

TimeInMillis	testing::internal::GetTimeInMillis ()

UnitTestImpl *	testing::internal::GetUnitTestImpl ()

	testing::GMOCK_DEFINE_bool_ (catch_leaked_mocks, true, "true iff Google Mock should report leaked mock objects " "as failures.")

	testing::GMOCK_DEFINE_string_ (verbose, internal::kWarningVerbosity, "Controls how verbose Google Mock's output is." " Valid values:\n" " info - prints all messages.\n" " warning - prints warnings and errors.\n" " error - prints errors only.")

	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_ (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_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_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_gmock_mutex)

GTEST_API_	testing::internal::GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)

static	testing::internal::GTEST_DEFINE_STATIC_MUTEX_ (g_log_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_ (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::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_ (flagfile, internal::StringFromGTestEnv("flagfile", ""), "This flag specifies the flagfile to read command-line flags from.")

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

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

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)

GTEST_API_ void	testing::InitGoogleMock (int argc, char *argv)

GTEST_API_ void	testing::InitGoogleMock (int argc, wchar_t *argv)

template<typename CharType >
void	testing::internal::InitGoogleMockImpl (int argc, CharType *argv)

GTEST_API_ void	testing::InitGoogleTest (int argc, char *argv)

GTEST_API_ void	testing::InitGoogleTest (int argc, wchar_t *argv)

template<typename CharType >
void	testing::internal::InitGoogleTestImpl (int argc, CharType *argv)

Int32	testing::internal::Int32FromEnvOrDie (const char *var, Int32 default_val)

GTEST_API_ Int32	testing::internal::Int32FromGTestEnv (const char *flag, Int32 default_val)

GTEST_API_ AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const ::std::string &needle, const ::std::string &haystack)

AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const ::std::wstring &needle, const ::std::wstring &haystack)

GTEST_API_ AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const char needle, const char haystack)

GTEST_API_ AssertionResult	testing::IsNotSubstring (const char needle_expr, const char haystack_expr, const wchar_t needle, const wchar_t haystack)

static bool	testing::internal::IsPathSeparator (char c)

bool	testing::internal::IsPrintableAscii (wchar_t c)

GTEST_API_ AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const ::std::string &needle, const ::std::string &haystack)

AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const ::std::wstring &needle, const ::std::wstring &haystack)

GTEST_API_ AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const char needle, const char haystack)

GTEST_API_ AssertionResult	testing::IsSubstring (const char needle_expr, const char haystack_expr, const wchar_t needle, const wchar_t haystack)

GTEST_API_ bool	testing::internal::IsTrue (bool condition)

bool	testing::internal::IsUtf16SurrogatePair (wchar_t first, wchar_t second)

GTEST_API_ std::string	testing::internal::JoinAsTuple (const Strings &fields)

void	testing::internal::LoadFlagsFromFile (const std::string &path)

GTEST_API_ void	testing::internal::Log (LogSeverity severity, const string &message, int stack_frames_to_skip)

static void	testing::internal::LogElementMatcherPairVec (const ElementMatcherPairs &pairs, ::std::ostream *stream)

GTEST_API_ bool	testing::internal::LogIsVisible (LogSeverity severity)

GTEST_API_ void	testing::internal::LogWithLocation (testing::internal::LogSeverity severity, const char *file, int line, const string &message)

GTEST_API_ TestInfo *	testing::internal::MakeAndRegisterTestInfo (const char test_suite_name, const char name, const char type_param, const char value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, TearDownTestSuiteFunc tear_down_tc, TestFactoryBase *factory)

std::ostream &	testing::operator<< (std::ostream &os, const TestPartResult &result)

static bool	testing::internal::ParseBoolFlag (const char str, const char flag, bool *value)

static const char *	testing::internal::ParseFlagValue (const char str, const char flag, bool def_optional)

static bool	testing::internal::ParseGoogleMockBoolFlag (const char str, const char flag, bool *value)

static const char *	testing::internal::ParseGoogleMockFlagValue (const char str, const char flag, bool def_optional)

template<typename String >
static bool	testing::internal::ParseGoogleMockStringFlag (const char str, const char flag, String *value)

static bool	testing::internal::ParseGoogleTestFlag (const char *const arg)

void	testing::internal::ParseGoogleTestFlagsOnly (int argc, char *argv)

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)

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)

static bool	testing::internal::PortableLocaltime (time_t seconds, struct tm *out)

template<typename UnsignedChar , typename Char >
static CharFormat	testing::internal::PrintAsCharLiteralTo (Char c, ostream *os)

static CharFormat	testing::internal::PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	testing::internal::PrintAsStringLiteralTo (wchar_t 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 >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	testing::internal::PrintCharsAsStringTo (const CharType begin, size_t len, ostream os)

static void	testing::internal::PrintColorEncoded (const char *str)

static 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 (const char s, ostream os)

void	testing::internal::PrintTo (const wchar_t s, ostream os)

GTEST_API_ void	testing::internal::PrintTo (signed char c, ::std::ostream *os)

GTEST_API_ void	testing::internal::PrintTo (unsigned char c, ::std::ostream *os)

void	testing::internal::PrintTo (wchar_t wc, ostream *os)

void	testing::internal::PrintWideStringTo (const ::std::wstring &s, ostream *os)

GTEST_API_ std::string	testing::internal::ReadEntireFile (FILE *file)

void	testing::internal::ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)

void	testing::internal::ReportInvalidTestCaseType (const char *test_case_name, CodeLocation code_location)

void	testing::internal::ReportUninterestingCall (CallReaction reaction, const string &msg)

static void	testing::internal::SetUpEnvironment (Environment *env)

static bool	testing::internal::ShouldRunTestCase (const TestCase *test_case)

bool	testing::internal::ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)

bool	testing::internal::ShouldShard (const char total_shards_env, const char shard_index_env, bool in_subprocess_for_death_test)

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)

GTEST_API_ bool	testing::internal::SkipPrefix (const char prefix, const char *pstr)

void	testing::internal::SplitString (const ::std::string &str, char delimiter, ::std::vector< ::std::string > *dest)

static void	testing::internal::StreamWideCharsToMessage (const wchar_t wstr, size_t length, Message msg)

const char *	testing::internal::StringFromGTestEnv (const char flag, const char default_val)

GTEST_API_ std::string	testing::internal::StringStreamToString (::std::stringstream *stream)

static int	testing::internal::SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)

static void	testing::internal::TearDownEnvironment (Environment *env)

std::string	testing::internal::TempDir ()

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 >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	testing::internal::UniversalPrintCharArray (const CharType begin, size_t len, ostream os)

static bool	testing::ValidateTestPropertyName (const std::string &property_name, const std::vector< std::string > &reserved_names)

std::string	testing::internal::WideStringToUtf8 (const wchar_t *str, int num_chars)

void	testing::internal::WriteToShardStatusFileIfNeeded ()

Variables
static CapturedStream *	testing::internal::g_captured_stderr = NULL

static CapturedStream *	testing::internal::g_captured_stdout = NULL

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"

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::kFlagfileFlag [] = "flagfile"

const char	testing::internal::kListTestsFlag [] = "list_tests"

const int	testing::internal::kMaxRandomSeed = 99999

const char	testing::internal::kOutputFlag [] = "output"

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

const char	testing::internal::kThrowOnFailureFlag [] = "throw_on_failure"

static const char	testing::internal::kTypeParamLabel [] = "TypeParam"

static const char	testing::kUniversalFilter [] = "*"

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; }\
    };\
    ::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 gmock-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; }\
    };\
    ::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 gmock-gtest-all.cc.

◆ EXPECT_NONFATAL_FAILURE

#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 gmock-gtest-all.cc.

◆ EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS

#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 gmock-gtest-all.cc.

◆ GTEST_HAS_GETTIMEOFDAY_

#define GTEST_HAS_GETTIMEOFDAY_ 1

Definition at line 385 of file gmock-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);\
  }\
}

Definition at line 2903 of file gmock-gtest-all.cc.

◆ GTEST_IMPLEMENTATION_ [1/4]

#define GTEST_IMPLEMENTATION_ 1

Definition at line 10219 of file gmock-gtest-all.cc.

◆ GTEST_IMPLEMENTATION_ [2/4]

#define GTEST_IMPLEMENTATION_ 1

Definition at line 10219 of file gmock-gtest-all.cc.

◆ GTEST_IMPLEMENTATION_ [3/4]

#define GTEST_IMPLEMENTATION_ 1

Definition at line 10219 of file gmock-gtest-all.cc.

◆ GTEST_IMPLEMENTATION_ [4/4]

#define GTEST_IMPLEMENTATION_ 1

Definition at line 10219 of file gmock-gtest-all.cc.

◆ GTEST_INCLUDE_GTEST_GTEST_SPI_H_

#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_

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

◆ GTEST_PATH_MAX_

#define GTEST_PATH_MAX_ _POSIX_PATH_MAX

Definition at line 8227 of file gmock-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 4742 of file gmock-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 4752 of file gmock-gtest-all.cc.

◆ GTEST_SRC_GTEST_INTERNAL_INL_H_

#define GTEST_SRC_GTEST_INTERNAL_INL_H_

Definition at line 448 of file gmock-gtest-all.cc.

Variable Documentation

◆ adds_

size_t adds_

private

Definition at line 2638 of file gmock-gtest-all.cc.

◆ common_

size_t common_

private

Definition at line 2638 of file gmock-gtest-all.cc.

◆ first_used_file

const char* first_used_file

Definition at line 11790 of file gmock-gtest-all.cc.

◆ first_used_line

int first_used_line

Definition at line 11791 of file gmock-gtest-all.cc.

◆ first_used_test

::std::string first_used_test

Definition at line 11793 of file gmock-gtest-all.cc.

◆ first_used_test_case

::std::string first_used_test_case

Definition at line 11792 of file gmock-gtest-all.cc.

◆ function_mockers

FunctionMockers function_mockers

Definition at line 11795 of file gmock-gtest-all.cc.

◆ hunk_

std::list<std::pair<char, const char*> > hunk_

private

Definition at line 2639 of file gmock-gtest-all.cc.

◆ hunk_adds_

std::list<std::pair<char, const char*> > hunk_adds_

private

Definition at line 2639 of file gmock-gtest-all.cc.

◆ hunk_removes_

std::list<std::pair<char, const char*> > hunk_removes_

private

Definition at line 2639 of file gmock-gtest-all.cc.

◆ ids_

IdMap ids_

private

Definition at line 2547 of file gmock-gtest-all.cc.

◆ leakable

bool leakable

Definition at line 11794 of file gmock-gtest-all.cc.

◆ left_start_

size_t left_start_

private

Definition at line 2637 of file gmock-gtest-all.cc.

◆ max_

const int max_

private

Definition at line 10531 of file gmock-gtest-all.cc.

◆ min_

const int min_

private

Definition at line 10530 of file gmock-gtest-all.cc.

◆ name_

std::string name_

private

Definition at line 4055 of file gmock-gtest-all.cc.

◆ removes_

size_t removes_

private

Definition at line 2638 of file gmock-gtest-all.cc.

◆ right_start_

size_t right_start_

private

Definition at line 2637 of file gmock-gtest-all.cc.

◆ states_

StateMap states_

private

Definition at line 11856 of file gmock-gtest-all.cc.

Classes

Namespaces

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ EXPECT_FATAL_FAILURE

◆ EXPECT_FATAL_FAILURE_ON_ALL_THREADS

◆ EXPECT_NONFATAL_FAILURE

◆ EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS

◆ GTEST_HAS_GETTIMEOFDAY_

◆ GTEST_IMPL_CMP_HELPER_

◆ GTEST_IMPLEMENTATION_ [1/4]

◆ GTEST_IMPLEMENTATION_ [2/4]

◆ GTEST_IMPLEMENTATION_ [3/4]

◆ GTEST_IMPLEMENTATION_ [4/4]

◆ GTEST_INCLUDE_GTEST_GTEST_SPI_H_

◆ GTEST_PATH_MAX_

◆ GTEST_REPEATER_METHOD_

◆ GTEST_REVERSE_REPEATER_METHOD_

◆ GTEST_SRC_GTEST_INTERNAL_INL_H_

Variable Documentation

◆ adds_

◆ common_

◆ first_used_file

◆ first_used_line

◆ first_used_test

◆ first_used_test_case

◆ function_mockers

◆ hunk_

◆ hunk_adds_

◆ hunk_removes_

◆ ids_

◆ leakable

◆ left_start_

◆ max_

◆ min_

◆ name_

◆ removes_

◆ right_start_

◆ states_