testing::internal::UnitTestImpl Class Reference

#include <gtest-internal-inl.h>

Public Types
enum	ReactionToSharding { HONOR_SHARDING_PROTOCOL , IGNORE_SHARDING_PROTOCOL }

Public Member Functions
	UnitTestImpl (UnitTest *parent)
virtual	~UnitTestImpl ()
TestPartResultReporterInterface *	GetGlobalTestPartResultReporter ()
void	SetGlobalTestPartResultReporter (TestPartResultReporterInterface *reporter)
TestPartResultReporterInterface *	GetTestPartResultReporterForCurrentThread ()
void	SetTestPartResultReporterForCurrentThread (TestPartResultReporterInterface *reporter)
int	successful_test_case_count () const
int	failed_test_case_count () const
int	total_test_case_count () const
int	test_case_to_run_count () const
int	successful_test_count () const
int	failed_test_count () const
int	reportable_disabled_test_count () const
int	disabled_test_count () const
int	reportable_test_count () const
int	total_test_count () const
int	test_to_run_count () const
TimeInMillis	start_timestamp () const
TimeInMillis	elapsed_time () const
bool	Passed () const
bool	Failed () const
const TestCase *	GetTestCase (int i) const
TestCase *	GetMutableTestCase (int i)
TestEventListeners *	listeners ()
TestResult *	current_test_result ()
const TestResult *	ad_hoc_test_result () const
void	set_os_stack_trace_getter (OsStackTraceGetterInterface *getter)
OsStackTraceGetterInterface *	os_stack_trace_getter ()
std::string	CurrentOsStackTraceExceptTop (int skip_count) GTEST_NO_INLINE_
TestCase *	GetTestCase (const char *test_case_name, const char *type_param, Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc)
void	AddTestInfo (Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc, TestInfo *test_info)
internal::ParameterizedTestCaseRegistry &	parameterized_test_registry ()
void	set_current_test_case (TestCase *a_current_test_case)
void	set_current_test_info (TestInfo *a_current_test_info)
void	RegisterParameterizedTests ()
bool	RunAllTests ()
void	ClearNonAdHocTestResult ()
void	ClearAdHocTestResult ()
void	RecordProperty (const TestProperty &test_property)
int	FilterTests (ReactionToSharding shard_tests)
void	ListTestsMatchingFilter ()
const TestCase *	current_test_case () const
TestInfo *	current_test_info ()
const TestInfo *	current_test_info () const
std::vector< Environment * > &	environments ()
std::vector< TraceInfo > &	gtest_trace_stack ()
const std::vector< TraceInfo > &	gtest_trace_stack () const
void	ConfigureXmlOutput ()
void	PostFlagParsingInit ()
int	random_seed () const
internal::Random *	random ()
void	ShuffleTests ()
void	UnshuffleTests ()
bool	catch_exceptions () const

Friends
class	::testing::UnitTest

Detailed Description

Definition at line 495 of file gtest-internal-inl.h.

Member Enumeration Documentation

ReactionToSharding

enum testing::internal::UnitTestImpl::ReactionToSharding

Enumerator
HONOR_SHARDING_PROTOCOL
IGNORE_SHARDING_PROTOCOL

Definition at line 711 of file gtest-internal-inl.h.

                          {
    HONOR_SHARDING_PROTOCOL,
    IGNORE_SHARDING_PROTOCOL
  };

Constructor & Destructor Documentation

UnitTestImpl()

testing::internal::UnitTestImpl::UnitTestImpl ( UnitTest * parent )

explicit

Definition at line 4730 of file gtest.cc.

    : parent_(parent),
      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
      default_global_test_part_result_reporter_(this),
      default_per_thread_test_part_result_reporter_(this),
      GTEST_DISABLE_MSC_WARNINGS_POP_()
      global_test_part_result_repoter_(
          &default_global_test_part_result_reporter_),
      per_thread_test_part_result_reporter_(
          &default_per_thread_test_part_result_reporter_),
      parameterized_test_registry_(),
      parameterized_tests_registered_(false),
      last_death_test_case_(-1),
      current_test_case_(NULL),
      current_test_info_(NULL),
      ad_hoc_test_result_(),
      os_stack_trace_getter_(NULL),
      post_flag_parse_init_performed_(false),
      random_seed_(0),  // Will be overridden by the flag before first use.
      random_(0),  // Will be reseeded before first use.
      start_timestamp_(0),
      elapsed_time_(0),
#if GTEST_HAS_DEATH_TEST
      death_test_factory_(new DefaultDeathTestFactory),
#endif
      // Will be overridden by the flag before first use.
      catch_exceptions_(false) {
  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
}

Here is the call graph for this function:

~UnitTestImpl()

testing::internal::UnitTestImpl::~UnitTestImpl ( )

virtual

Definition at line 4760 of file gtest.cc.

                            {
  // Deletes every TestCase.
  ForEach(test_cases_, internal::Delete<TestCase>);
 
  // Deletes every Environment.
  ForEach(environments_, internal::Delete<Environment>);
 
  delete os_stack_trace_getter_;
}

Here is the call graph for this function:

Member Function Documentation

ad_hoc_test_result()

const TestResult * testing::internal::UnitTestImpl::ad_hoc_test_result ( ) const

inline

Definition at line 593 of file gtest-internal-inl.h.

{ return &ad_hoc_test_result_; }

AddTestInfo()

void testing::internal::UnitTestImpl::AddTestInfo ( Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc, TestInfo * test_info )

inline

Definition at line 641 of file gtest-internal-inl.h.

                                        {
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }
 
    GetTestCase(test_info->test_case_name(),
                test_info->type_param(),
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

catch_exceptions()

bool testing::internal::UnitTestImpl::catch_exceptions ( ) const

inline

Definition at line 797 of file gtest-internal-inl.h.

{ return catch_exceptions_; }

ClearAdHocTestResult()

void testing::internal::UnitTestImpl::ClearAdHocTestResult ( )

inline

Definition at line 701 of file gtest-internal-inl.h.

                              {
    ad_hoc_test_result_.Clear();
  }

ClearNonAdHocTestResult()

void testing::internal::UnitTestImpl::ClearNonAdHocTestResult ( )

inline

Definition at line 696 of file gtest-internal-inl.h.

                                 {
    ForEach(test_cases_, TestCase::ClearTestCaseResult);
  }

Here is the caller graph for this function:

ConfigureXmlOutput()

void testing::internal::UnitTestImpl::ConfigureXmlOutput

(

)

Definition at line 4803 of file gtest.cc.

                                      {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format == "json") {
    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format != "") {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
                        << output_format << "\" ignored.";
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

current_test_case()

const TestCase * testing::internal::UnitTestImpl::current_test_case ( ) const

inline

Definition at line 727 of file gtest-internal-inl.h.

{ return current_test_case_; }

Here is the caller graph for this function:

current_test_info() [1/2]

TestInfo * testing::internal::UnitTestImpl::current_test_info ( )

inline

Definition at line 728 of file gtest-internal-inl.h.

{ return current_test_info_; }

Here is the caller graph for this function:

current_test_info() [2/2]

const TestInfo * testing::internal::UnitTestImpl::current_test_info ( ) const

inline

Definition at line 729 of file gtest-internal-inl.h.

{ return current_test_info_; }

current_test_result()

TestResult * testing::internal::UnitTestImpl::current_test_result

(

)

Definition at line 5345 of file gtest.cc.

                                              {
  if (current_test_info_ != NULL) {
    return &current_test_info_->result_;
  }
  if (current_test_case_ != NULL) {
    return &current_test_case_->ad_hoc_test_result_;
  }
  return &ad_hoc_test_result_;
}

Here is the caller graph for this function:

CurrentOsStackTraceExceptTop()

std::string testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop

(

int

skip_count

)

Definition at line 810 of file gtest.cc.

                                                                   {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
      skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
      );  // NOLINT
}

Here is the call graph for this function:

Here is the caller graph for this function:

disabled_test_count()

int testing::internal::UnitTestImpl::disabled_test_count

(

)

const

Definition at line 781 of file gtest.cc.

                                            {
  return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
}

Here is the call graph for this function:

elapsed_time()

TimeInMillis testing::internal::UnitTestImpl::elapsed_time ( ) const

inline

Definition at line 560 of file gtest-internal-inl.h.

{ return elapsed_time_; }

environments()

std::vector< Environment * > & testing::internal::UnitTestImpl::environments ( )

inline

Definition at line 733 of file gtest-internal-inl.h.

{ return environments_; }

Failed()

bool testing::internal::UnitTestImpl::Failed ( ) const

inline

Definition at line 567 of file gtest-internal-inl.h.

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

failed_test_case_count()

int testing::internal::UnitTestImpl::failed_test_case_count

(

)

const

Definition at line 749 of file gtest.cc.

                                               {
  return CountIf(test_cases_, TestCaseFailed);
}

Here is the call graph for this function:

failed_test_count()

int testing::internal::UnitTestImpl::failed_test_count

(

)

const

Definition at line 770 of file gtest.cc.

                                          {
  return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
}

Here is the call graph for this function:

FilterTests()

int testing::internal::UnitTestImpl::FilterTests

(

ReactionToSharding

shard_tests

)

Definition at line 5202 of file gtest.cc.

                                                            {
  const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
  const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
 
  // num_runnable_tests are the number of tests that will
  // run across all shards (i.e., match filter and are not disabled).
  // num_selected_tests are the number of tests to be run on
  // this shard.
  int num_runnable_tests = 0;
  int num_selected_tests = 0;
  for (size_t i = 0; i < test_cases_.size(); i++) {
    TestCase* const test_case = test_cases_[i];
    const std::string &test_case_name = test_case->name();
    test_case->set_should_run(false);
 
    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
      TestInfo* const test_info = test_case->test_info_list()[j];
      const std::string test_name(test_info->name());
      // A test is disabled if test case name or test name matches
      // kDisableTestFilter.
      const bool is_disabled =
          internal::UnitTestOptions::MatchesFilter(test_case_name,
                                                   kDisableTestFilter) ||
          internal::UnitTestOptions::MatchesFilter(test_name,
                                                   kDisableTestFilter);
      test_info->is_disabled_ = is_disabled;
 
      const bool matches_filter =
          internal::UnitTestOptions::FilterMatchesTest(test_case_name,
                                                       test_name);
      test_info->matches_filter_ = matches_filter;
 
      const bool is_runnable =
          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
          matches_filter;
 
      const bool is_in_another_shard =
          shard_tests != IGNORE_SHARDING_PROTOCOL &&
          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
      test_info->is_in_another_shard_ = is_in_another_shard;
      const bool is_selected = is_runnable && !is_in_another_shard;
 
      num_runnable_tests += is_runnable;
      num_selected_tests += is_selected;
 
      test_info->should_run_ = is_selected;
      test_case->set_should_run(test_case->should_run() || is_selected);
    }
  }
  return num_selected_tests;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetGlobalTestPartResultReporter()

TestPartResultReporterInterface * testing::internal::UnitTestImpl::GetGlobalTestPartResultReporter

(

)

Definition at line 719 of file gtest.cc.

                                              {
  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
  return global_test_part_result_repoter_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMutableTestCase()

TestCase * testing::internal::UnitTestImpl::GetMutableTestCase ( int i )

inline

Definition at line 580 of file gtest-internal-inl.h.

                                      {
    const int index = GetElementOr(test_case_indices_, i, -1);
    return index < 0 ? NULL : test_cases_[index];
  }

Here is the caller graph for this function:

GetTestCase() [1/2]

TestCase * testing::internal::UnitTestImpl::GetTestCase	(	const char *	test_case_name,
		const char *	type_param,
		Test::SetUpTestCaseFunc	set_up_tc,
		Test::TearDownTestCaseFunc	tear_down_tc )

Definition at line 4906 of file gtest.cc.

                                                                           {
  // Can we find a TestCase with the given name?
  const std::vector<TestCase*>::const_reverse_iterator test_case =
      std::find_if(test_cases_.rbegin(), test_cases_.rend(),
                   TestCaseNameIs(test_case_name));
 
  if (test_case != test_cases_.rend())
    return *test_case;
 
  // No.  Let's create one.
  TestCase* const new_test_case =
      new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
 
  // Is this a death test case?
  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
                                               kDeathTestCaseFilter)) {
    // Yes.  Inserts the test case after the last death test case
    // defined so far.  This only works when the test cases haven't
    // been shuffled.  Otherwise we may end up running a death test
    // after a non-death test.
    ++last_death_test_case_;
    test_cases_.insert(test_cases_.begin() + last_death_test_case_,
                       new_test_case);
  } else {
    // No.  Appends to the end of the list.
    test_cases_.push_back(new_test_case);
  }
 
  test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
  return new_test_case;
}

Here is the call graph for this function:

GetTestCase() [2/2]

const TestCase * testing::internal::UnitTestImpl::GetTestCase ( int i ) const

inline

Definition at line 573 of file gtest-internal-inl.h.

                                           {
    const int index = GetElementOr(test_case_indices_, i, -1);
    return index < 0 ? NULL : test_cases_[i];
  }

GetTestPartResultReporterForCurrentThread()

TestPartResultReporterInterface * testing::internal::UnitTestImpl::GetTestPartResultReporterForCurrentThread

(

)

Definition at line 733 of file gtest.cc.

                                                        {
  return per_thread_test_part_result_reporter_.get();
}

gtest_trace_stack() [1/2]

std::vector< TraceInfo > & testing::internal::UnitTestImpl::gtest_trace_stack ( )

inline

Definition at line 736 of file gtest-internal-inl.h.

                                            {
    return *(gtest_trace_stack_.pointer());
  }

gtest_trace_stack() [2/2]

const std::vector< TraceInfo > & testing::internal::UnitTestImpl::gtest_trace_stack ( ) const

inline

Definition at line 739 of file gtest-internal-inl.h.

                                                        {
    return gtest_trace_stack_.get();
  }

listeners()

TestEventListeners * testing::internal::UnitTestImpl::listeners ( )

inline

Definition at line 586 of file gtest-internal-inl.h.

{ return &listeners_; }

Here is the caller graph for this function:

ListTestsMatchingFilter()

void testing::internal::UnitTestImpl::ListTestsMatchingFilter

(

)

Definition at line 5279 of file gtest.cc.

                                           {
  // Print at most this many characters for each type/value parameter.
  const int kMaxParamLength = 250;
 
  for (size_t i = 0; i < test_cases_.size(); i++) {
    const TestCase* const test_case = test_cases_[i];
    bool printed_test_case_name = false;
 
    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
      const TestInfo* const test_info =
          test_case->test_info_list()[j];
      if (test_info->matches_filter_) {
        if (!printed_test_case_name) {
          printed_test_case_name = true;
          printf("%s.", test_case->name());
          if (test_case->type_param() != NULL) {
            printf("  # %s = ", kTypeParamLabel);
            // We print the type parameter on a single line to make
            // the output easy to parse by a program.
            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
          }
          printf("\n");
        }
        printf("  %s", test_info->name());
        if (test_info->value_param() != NULL) {
          printf("  # %s = ", kValueParamLabel);
          // We print the value parameter on a single line to make the
          // output easy to parse by a program.
          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
        }
        printf("\n");
      }
    }
  }
  fflush(stdout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

os_stack_trace_getter()

OsStackTraceGetterInterface * testing::internal::UnitTestImpl::os_stack_trace_getter

(

)

Definition at line 5332 of file gtest.cc.

                                                                 {
  if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }
 
  return os_stack_trace_getter_;
}

Here is the caller graph for this function:

parameterized_test_registry()

internal::ParameterizedTestCaseRegistry & testing::internal::UnitTestImpl::parameterized_test_registry ( )

inline

Definition at line 665 of file gtest-internal-inl.h.

                                                                       {
    return parameterized_test_registry_;
  }

Here is the caller graph for this function:

Passed()

bool testing::internal::UnitTestImpl::Passed ( ) const

inline

Definition at line 563 of file gtest-internal-inl.h.

{ return !Failed(); }

Here is the caller graph for this function:

PostFlagParsingInit()

void testing::internal::UnitTestImpl::PostFlagParsingInit

(

)

Definition at line 4840 of file gtest.cc.

                                       {
  // Ensures that this function does not execute more than once.
  if (!post_flag_parse_init_performed_) {
    post_flag_parse_init_performed_ = true;
 
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
    // Register to send notifications about key process state changes.
    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 
#if GTEST_HAS_DEATH_TEST
    InitDeathTestSubprocessControlInfo();
    SuppressTestEventsIfInSubprocess();
#endif  // GTEST_HAS_DEATH_TEST
 
    // Registers parameterized tests. This makes parameterized tests
    // available to the UnitTest reflection API without running
    // RUN_ALL_TESTS.
    RegisterParameterizedTests();
 
    // Configures listeners for XML output. This makes it possible for users
    // to shut down the default XML output before invoking RUN_ALL_TESTS.
    ConfigureXmlOutput();
 
#if GTEST_CAN_STREAM_RESULTS_
    // Configures listeners for streaming test results to the specified server.
    ConfigureStreamingOutput();
#endif  // GTEST_CAN_STREAM_RESULTS_
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

random()

internal::Random * testing::internal::UnitTestImpl::random ( )

inline

Definition at line 786 of file gtest-internal-inl.h.

{ return &random_; }

Here is the caller graph for this function:

random_seed()

int testing::internal::UnitTestImpl::random_seed ( ) const

inline

Definition at line 783 of file gtest-internal-inl.h.

{ return random_seed_; }

Here is the caller graph for this function:

RecordProperty()

void testing::internal::UnitTestImpl::RecordProperty

(

const TestProperty &

test_property

)

Definition at line 4775 of file gtest.cc.

                                                                   {
  std::string xml_element;
  TestResult* test_result;  // TestResult appropriate for property recording.
 
  if (current_test_info_ != NULL) {
    xml_element = "testcase";
    test_result = &(current_test_info_->result_);
  } else if (current_test_case_ != NULL) {
    xml_element = "testsuite";
    test_result = &(current_test_case_->ad_hoc_test_result_);
  } else {
    xml_element = "testsuites";
    test_result = &ad_hoc_test_result_;
  }
  test_result->RecordProperty(xml_element, test_property);
}

RegisterParameterizedTests()

void testing::internal::UnitTestImpl::RegisterParameterizedTests

(

)

Definition at line 2631 of file gtest.cc.

                                              {
  if (!parameterized_tests_registered_) {
    parameterized_test_registry_.RegisterTests();
    parameterized_tests_registered_ = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

reportable_disabled_test_count()

int testing::internal::UnitTestImpl::reportable_disabled_test_count

(

)

const

Definition at line 775 of file gtest.cc.

                                                       {
  return SumOverTestCaseList(test_cases_,
                             &TestCase::reportable_disabled_test_count);
}

Here is the call graph for this function:

reportable_test_count()

int testing::internal::UnitTestImpl::reportable_test_count

(

)

const

Definition at line 786 of file gtest.cc.

                                              {
  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
}

Here is the call graph for this function:

RunAllTests()

bool testing::internal::UnitTestImpl::RunAllTests

(

)

Definition at line 4955 of file gtest.cc.

                               {
  // True iff Google Test is initialized before RUN_ALL_TESTS() is called.
  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
 
  // Do not run any test if the --help flag was specified.
  if (g_help_flag)
    return true;
 
  // Repeats the call to the post-flag parsing initialization in case the
  // user didn't call InitGoogleTest.
  PostFlagParsingInit();
 
  // Even if sharding is not on, test runners may want to use the
  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
  // protocol.
  internal::WriteToShardStatusFileIfNeeded();
 
  // True iff we are in a subprocess for running a thread-safe-style
  // death test.
  bool in_subprocess_for_death_test = false;
 
#if GTEST_HAS_DEATH_TEST
  in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL);
# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
  if (in_subprocess_for_death_test) {
    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
  }
# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
#endif  // GTEST_HAS_DEATH_TEST
 
  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
                                        in_subprocess_for_death_test);
 
  // Compares the full test names with the filter to decide which
  // tests to run.
  const bool has_tests_to_run = FilterTests(should_shard
                                              ? HONOR_SHARDING_PROTOCOL
                                              : IGNORE_SHARDING_PROTOCOL) > 0;
 
  // Lists the tests and exits if the --gtest_list_tests flag was specified.
  if (GTEST_FLAG(list_tests)) {
    // This must be called *after* FilterTests() has been called.
    ListTestsMatchingFilter();
    return true;
  }
 
  random_seed_ = GTEST_FLAG(shuffle) ?
      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
 
  // True iff at least one test has failed.
  bool failed = false;
 
  TestEventListener* repeater = listeners()->repeater();
 
  start_timestamp_ = GetTimeInMillis();
  repeater->OnTestProgramStart(*parent_);
 
  // How many times to repeat the tests?  We don't want to repeat them
  // when we are inside the subprocess of a death test.
  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
  // Repeats forever if the repeat count is negative.
  const bool forever = repeat < 0;
  for (int i = 0; forever || i != repeat; i++) {
    // We want to preserve failures generated by ad-hoc test
    // assertions executed before RUN_ALL_TESTS().
    ClearNonAdHocTestResult();
 
    const TimeInMillis start = GetTimeInMillis();
 
    // Shuffles test cases and tests if requested.
    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
      random()->Reseed(random_seed_);
      // This should be done before calling OnTestIterationStart(),
      // such that a test event listener can see the actual test order
      // in the event.
      ShuffleTests();
    }
 
    // Tells the unit test event listeners that the tests are about to start.
    repeater->OnTestIterationStart(*parent_, i);
 
    // Runs each test case if there is at least one test to run.
    if (has_tests_to_run) {
      // Sets up all environments beforehand.
      repeater->OnEnvironmentsSetUpStart(*parent_);
      ForEach(environments_, SetUpEnvironment);
      repeater->OnEnvironmentsSetUpEnd(*parent_);
 
      // Runs the tests only if there was no fatal failure during global
      // set-up.
      if (!Test::HasFatalFailure()) {
        for (int test_index = 0; test_index < total_test_case_count();
             test_index++) {
          GetMutableTestCase(test_index)->Run();
        }
      }
 
      // Tears down all environments in reverse order afterwards.
      repeater->OnEnvironmentsTearDownStart(*parent_);
      std::for_each(environments_.rbegin(), environments_.rend(),
                    TearDownEnvironment);
      repeater->OnEnvironmentsTearDownEnd(*parent_);
    }
 
    elapsed_time_ = GetTimeInMillis() - start;
 
    // Tells the unit test event listener that the tests have just finished.
    repeater->OnTestIterationEnd(*parent_, i);
 
    // Gets the result and clears it.
    if (!Passed()) {
      failed = true;
    }
 
    // Restores the original test order after the iteration.  This
    // allows the user to quickly repro a failure that happens in the
    // N-th iteration without repeating the first (N - 1) iterations.
    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
    // case the user somehow changes the value of the flag somewhere
    // (it's always safe to unshuffle the tests).
    UnshuffleTests();
 
    if (GTEST_FLAG(shuffle)) {
      // Picks a new random seed for each iteration.
      random_seed_ = GetNextRandomSeed(random_seed_);
    }
  }
 
  repeater->OnTestProgramEnd(*parent_);
 
  if (!gtest_is_initialized_before_run_all_tests) {
    ColoredPrintf(
        COLOR_RED,
        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
        " will start to enforce the valid usage. "
        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
#if GTEST_FOR_GOOGLE_
    ColoredPrintf(COLOR_RED,
                  "For more details, see http://wiki/Main/ValidGUnitMain.\n");
#endif  // GTEST_FOR_GOOGLE_
  }
 
  return !failed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_current_test_case()

void testing::internal::UnitTestImpl::set_current_test_case ( TestCase * a_current_test_case )

inline

Definition at line 670 of file gtest-internal-inl.h.

                                                            {
    current_test_case_ = a_current_test_case;
  }

set_current_test_info()

void testing::internal::UnitTestImpl::set_current_test_info ( TestInfo * a_current_test_info )

inline

Definition at line 677 of file gtest-internal-inl.h.

                                                            {
    current_test_info_ = a_current_test_info;
  }

set_os_stack_trace_getter()

void testing::internal::UnitTestImpl::set_os_stack_trace_getter

(

OsStackTraceGetterInterface *

getter

)

Definition at line 5321 of file gtest.cc.

                                         {
  if (os_stack_trace_getter_ != getter) {
    delete os_stack_trace_getter_;
    os_stack_trace_getter_ = getter;
  }
}

SetGlobalTestPartResultReporter()

void testing::internal::UnitTestImpl::SetGlobalTestPartResultReporter

(

TestPartResultReporterInterface *

reporter

)

Definition at line 725 of file gtest.cc.

                                               {
  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
  global_test_part_result_repoter_ = reporter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetTestPartResultReporterForCurrentThread()

void testing::internal::UnitTestImpl::SetTestPartResultReporterForCurrentThread

(

TestPartResultReporterInterface *

reporter

)

Definition at line 738 of file gtest.cc.

                                               {
  per_thread_test_part_result_reporter_.set(reporter);
}

Here is the caller graph for this function:

ShuffleTests()

void testing::internal::UnitTestImpl::ShuffleTests

(

)

Definition at line 5357 of file gtest.cc.

                                {
  // Shuffles the death test cases.
  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
 
  // Shuffles the non-death test cases.
  ShuffleRange(random(), last_death_test_case_ + 1,
               static_cast<int>(test_cases_.size()), &test_case_indices_);
 
  // Shuffles the tests inside each test case.
  for (size_t i = 0; i < test_cases_.size(); i++) {
    test_cases_[i]->ShuffleTests(random());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_timestamp()

TimeInMillis testing::internal::UnitTestImpl::start_timestamp ( ) const

inline

Definition at line 557 of file gtest-internal-inl.h.

{ return start_timestamp_; }

successful_test_case_count()

int testing::internal::UnitTestImpl::successful_test_case_count

(

)

const

Definition at line 744 of file gtest.cc.

                                                   {
  return CountIf(test_cases_, TestCasePassed);
}

Here is the call graph for this function:

successful_test_count()

int testing::internal::UnitTestImpl::successful_test_count

(

)

const

Definition at line 765 of file gtest.cc.

                                              {
  return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
}

Here is the call graph for this function:

test_case_to_run_count()

int testing::internal::UnitTestImpl::test_case_to_run_count

(

)

const

Definition at line 760 of file gtest.cc.

                                               {
  return CountIf(test_cases_, ShouldRunTestCase);
}

Here is the call graph for this function:

test_to_run_count()

int testing::internal::UnitTestImpl::test_to_run_count

(

)

const

Definition at line 796 of file gtest.cc.

                                          {
  return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
}

Here is the call graph for this function:

total_test_case_count()

int testing::internal::UnitTestImpl::total_test_case_count

(

)

const

Definition at line 754 of file gtest.cc.

                                              {
  return static_cast<int>(test_cases_.size());
}

Here is the caller graph for this function:

total_test_count()

int testing::internal::UnitTestImpl::total_test_count

(

)

const

Definition at line 791 of file gtest.cc.

                                         {
  return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
}

Here is the call graph for this function:

UnshuffleTests()

void testing::internal::UnitTestImpl::UnshuffleTests

(

)

Definition at line 5372 of file gtest.cc.

                                  {
  for (size_t i = 0; i < test_cases_.size(); i++) {
    // Unshuffles the tests in each test case.
    test_cases_[i]->UnshuffleTests();
    // Resets the index of each test case.
    test_case_indices_[i] = static_cast<int>(i);
  }
}

Here is the caller graph for this function:

Friends And Related Symbol Documentation

::testing::UnitTest

friend class ::testing::UnitTest

friend

Definition at line 800 of file gtest-internal-inl.h.

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/crypto/webauthn_json/thirdparty/gtest/googletest/src/gtest-internal-inl.h
• libraries/fc/include/fc/crypto/webauthn_json/thirdparty/gtest/googletest/src/gtest.cc