#include "gtest/gtest.h"

#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_

#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_

namespace testing {

class GTEST_API_ ScopedFakeTestPartResultReporter

: public TestPartResultReporterInterface {

public:

// The two possible mocking modes of this object.

enum InterceptMode {

INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures.

INTERCEPT_ALL_THREADS // Intercepts all failures.

};

// The c'tor sets this object as the test part result reporter used

// by Google Test. The 'result' parameter specifies where to report the

// results. This reporter will only catch failures generated in the current

// thread. DEPRECATED

explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);

// Same as above, but you can choose the interception scope of this object.

ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,

TestPartResultArray* result);

// The d'tor restores the previous test part result reporter.

virtual ~ScopedFakeTestPartResultReporter();

// Appends the TestPartResult object to the TestPartResultArray

// received in the constructor.

//

// This method is from the TestPartResultReporterInterface

// interface.

virtual void ReportTestPartResult(const TestPartResult& result);

private:

void Init();

const InterceptMode intercept_mode_;

TestPartResultReporterInterface* old_reporter_;

TestPartResultArray* const result_;

GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);

};

namespace internal {

class GTEST_API_ SingleFailureChecker {

public:

// The constructor remembers the arguments.

SingleFailureChecker(const TestPartResultArray* results,

TestPartResult::Type type,

const string& substr);

~SingleFailureChecker();

private:

const TestPartResultArray* const results_;

const TestPartResult::Type type_;

const string substr_;

GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);

};

} // namespace internal

} // namespace testing

#define EXPECT_FATAL_FAILURE(statement, substr) \

} while (::testing::internal::AlwaysFalse())

#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \

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

#define EXPECT_NONFATAL_FAILURE(statement, substr) \

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

#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \

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

#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_

#include <ctype.h>

#include <math.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <wchar.h>

#include <wctype.h>

#include <algorithm>

#include <ostream> // NOLINT

#include <sstream>

#include <vector>

#if GTEST_OS_LINUX

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <fcntl.h> // NOLINT

# include <limits.h> // NOLINT

# include <sched.h> // NOLINT

# include <strings.h> // NOLINT

# include <sys/mman.h> // NOLINT

# include <sys/time.h> // NOLINT

# include <unistd.h> // NOLINT

# include <string>

#elif GTEST_OS_SYMBIAN

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <sys/time.h> // NOLINT

#elif GTEST_OS_ZOS

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <sys/time.h> // NOLINT

# include <strings.h> // NOLINT

#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE.

# include <windows.h> // NOLINT

#elif GTEST_OS_WINDOWS // We are on Windows proper.

# include <io.h> // NOLINT

# include <sys/timeb.h> // NOLINT

# include <sys/types.h> // NOLINT

# include <sys/stat.h> // NOLINT

# if GTEST_OS_WINDOWS_MINGW

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <sys/time.h> // NOLINT

# endif // GTEST_OS_WINDOWS_MINGW

# include <windows.h> // NOLINT

#else

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <sys/time.h> // NOLINT

# include <unistd.h> // NOLINT

#endif // GTEST_OS_LINUX

#if GTEST_HAS_EXCEPTIONS

# include <stdexcept>

#endif

#if GTEST_CAN_STREAM_RESULTS_

# include <arpa/inet.h> // NOLINT

# include <netdb.h> // NOLINT

#endif

#define GTEST_IMPLEMENTATION_ 1

#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_

#define GTEST_SRC_GTEST_INTERNAL_INL_H_

#if !GTEST_IMPLEMENTATION_

# error "gtest-internal-inl.h is part of Google Test's internal implementation."

# error "It must not be included except by Google Test itself."

#endif // GTEST_IMPLEMENTATION_

#ifndef _WIN32_WCE

# include <errno.h>

#endif // !_WIN32_WCE

#include <stddef.h>

#include <stdlib.h> // For strtoll/_strtoul64/malloc/free.

#include <string.h> // For memmove.

#include <algorithm>

#include <string>

#include <vector>

#if GTEST_OS_WINDOWS

# include <windows.h> // NOLINT

#endif // GTEST_OS_WINDOWS

namespace testing {

GTEST_DECLARE_bool_(death_test_use_fork);

namespace internal {

GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;

const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";

const char kBreakOnFailureFlag[] = "break_on_failure";

const char kCatchExceptionsFlag[] = "catch_exceptions";

const char kColorFlag[] = "color";

const char kFilterFlag[] = "filter";

const char kListTestsFlag[] = "list_tests";

const char kOutputFlag[] = "output";

const char kPrintTimeFlag[] = "print_time";

const char kRandomSeedFlag[] = "random_seed";

const char kRepeatFlag[] = "repeat";

const char kShuffleFlag[] = "shuffle";

const char kStackTraceDepthFlag[] = "stack_trace_depth";

const char kStreamResultToFlag[] = "stream_result_to";

const char kThrowOnFailureFlag[] = "throw_on_failure";

const int kMaxRandomSeed = 99999;

GTEST_API_ extern bool g_help_flag;

GTEST_API_ TimeInMillis GetTimeInMillis();

GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);

GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);

GTEST_API_ bool ParseInt32Flag(

const char* str, const char* flag, Int32* value);

inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {

}

inline int GetNextRandomSeed(int seed) {

}

class GTestFlagSaver {

} GTEST_ATTRIBUTE_UNUSED_;

GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);

GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars);

void WriteToShardStatusFileIfNeeded();

GTEST_API_ bool ShouldShard(const char* total_shards_str,

const char* shard_index_str,

bool in_subprocess_for_death_test);

GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);

GTEST_API_ bool ShouldRunTestOnShard(

int total_shards, int shard_index, int test_id);

template <class Container, typename Predicate>

inline int CountIf(const Container& c, Predicate predicate) {

}

template <class Container, typename Functor>

void ForEach(const Container& c, Functor functor) {

std::for_each(c.begin(), c.end(), functor);

}

template <typename E>

inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {

return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];

}

template <typename E>

void ShuffleRange(internal::Random* random, int begin, int end,

}

template <typename E>

inline void Shuffle(internal::Random* random, std::vector<E>* v) {

ShuffleRange(random, 0, static_cast<int>(v->size()), v);

}

template <typename T>

static void Delete(T* x) {

delete x;

}

class TestPropertyKeyIs {

};

class GTEST_API_ UnitTestOptions {

public:

// Functions for processing the gtest_output flag.

// Returns the output format, or "" for normal printed output.

static String GetOutputFormat();

// Returns the absolute path of the requested output file, or the

// default (test_detail.xml in the original working directory) if

// none was explicitly specified.

static String GetAbsolutePathToOutputFile();

// Functions for processing the gtest_filter flag.

// Returns true iff the wildcard pattern matches the string. The

// first ':' or '\0' character in pattern marks the end of it.

//

// This recursive algorithm isn't very efficient, but is clear and

// works well enough for matching test names, which are short.

static bool PatternMatchesString(const char *pattern, const char *str);

// Returns true iff the user-specified filter matches the test case

// name and the test name.

static bool FilterMatchesTest(const String &test_case_name,

const String &test_name);

#if GTEST_OS_WINDOWS

// Function for supporting the gtest_catch_exception flag.

// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the

// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.

// This function is useful as an __except condition.

static int GTestShouldProcessSEH(DWORD exception_code);

#endif // GTEST_OS_WINDOWS

// Returns true if "name" matches the ':' separated list of glob-style

// filters in "filter".

static bool MatchesFilter(const String& name, const char* filter);

};

GTEST_API_ FilePath GetCurrentExecutableName();

class OsStackTraceGetterInterface {

};

class OsStackTraceGetter : public OsStackTraceGetterInterface {

};

struct TraceInfo {

};

class DefaultGlobalTestPartResultReporter

};

class DefaultPerThreadTestPartResultReporter

};

class GTEST_API_ UnitTestImpl {

public:

explicit UnitTestImpl(UnitTest* parent);

virtual ~UnitTestImpl();

// There are two different ways to register your own TestPartResultReporter.

// You can register your own repoter to listen either only for test results

// from the current thread or for results from all threads.

// By default, each per-thread test result repoter just passes a new

// TestPartResult to the global test result reporter, which registers the

// test part result for the currently running test.

// Returns the global test part result reporter.

TestPartResultReporterInterface* GetGlobalTestPartResultReporter();

// Sets the global test part result reporter.

void SetGlobalTestPartResultReporter(

TestPartResultReporterInterface* reporter);

// Returns the test part result reporter for the current thread.

TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();

// Sets the test part result reporter for the current thread.

void SetTestPartResultReporterForCurrentThread(

TestPartResultReporterInterface* reporter);

// Gets the number of successful test cases.

int successful_test_case_count() const;

// Gets the number of failed test cases.

int failed_test_case_count() const;

// Gets the number of all test cases.

int total_test_case_count() const;

// Gets the number of all test cases that contain at least one test

// that should run.

int test_case_to_run_count() const;

// Gets the number of successful tests.

int successful_test_count() const;

// Gets the number of failed tests.

int failed_test_count() const;

// Gets the number of disabled tests.

int disabled_test_count() const;

// Gets the number of all tests.

int total_test_count() const;

// Gets the number of tests that should run.

int test_to_run_count() const;

// Gets the elapsed time, in milliseconds.

TimeInMillis elapsed_time() const { return elapsed_time_; }

// Returns true iff the unit test passed (i.e. all test cases passed).

bool Passed() const { return !Failed(); }

// Returns true iff the unit test failed (i.e. some test case failed

// or something outside of all tests failed).

bool Failed() const {

return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();

}

// Gets the i-th test case among all the test cases. i can range from 0 to

// total_test_case_count() - 1. If i is not in that range, returns NULL.

const TestCase* GetTestCase(int i) const {

const int index = GetElementOr(test_case_indices_, i, -1);

return index < 0 ? NULL : test_cases_[i];

}

// Gets the i-th test case among all the test cases. i can range from 0 to

// total_test_case_count() - 1. If i is not in that range, returns NULL.

TestCase* GetMutableTestCase(int i) {

const int index = GetElementOr(test_case_indices_, i, -1);

return index < 0 ? NULL : test_cases_[index];

}

// Provides access to the event listener list.

TestEventListeners* listeners() { return &listeners_; }

// Returns the TestResult for the test that's currently running, or

// the TestResult for the ad hoc test if no test is running.

TestResult* current_test_result();

// Returns the TestResult for the ad hoc test.

const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }

// Sets the OS stack trace getter.

//

// Does nothing if the input and the current OS stack trace getter

// are the same; otherwise, deletes the old getter and makes the

// input the current getter.

void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);

// Returns the current OS stack trace getter if it is not NULL;

// otherwise, creates an OsStackTraceGetter, makes it the current

// getter, and returns it.

OsStackTraceGetterInterface* os_stack_trace_getter();

// Returns the current OS stack trace as a String.

//

// The maximum number of stack frames to be included is specified by

// the gtest_stack_trace_depth flag. The skip_count parameter

// specifies the number of top frames to be skipped, which doesn't