Subversion Repositories Kolibri OS

// Copyright 2005, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: wan@google.com (Zhanyong Wan)

//

// The Google C++ Testing Framework (Google Test)

#include "gtest/gtest.h"

#include "gtest/gtest-spi.h"

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include   // NOLINT

#include 

#include 

#if GTEST_OS_LINUX

// TODO(kenton@google.com): Use autoconf to detect availability of

// gettimeofday().

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include   // NOLINT

# include   // NOLINT

# include   // NOLINT

// Declares vsnprintf().  This header is not available on Windows.

# include   // NOLINT

# include   // NOLINT

# include   // NOLINT

# include   // NOLINT

# include 

#elif GTEST_OS_SYMBIAN

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include   // NOLINT

#elif GTEST_OS_ZOS

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include   // NOLINT

// On z/OS we additionally need strings.h for strcasecmp.

# include   // NOLINT

#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.

# include   // NOLINT

#elif GTEST_OS_WINDOWS  // We are on Windows proper.

# include   // NOLINT

# include   // NOLINT

# include   // NOLINT

# include   // NOLINT

# if GTEST_OS_WINDOWS_MINGW

// MinGW has gettimeofday() but not _ftime64().

// TODO(kenton@google.com): Use autoconf to detect availability of

//   gettimeofday().

// TODO(kenton@google.com): There are other ways to get the time on

//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW

//   supports these.  consider using them instead.

#  define GTEST_HAS_GETTIMEOFDAY_ 1

#  include   // NOLINT

# endif  // GTEST_OS_WINDOWS_MINGW

// cpplint thinks that the header is already included, so we want to

// silence it.

# include   // NOLINT

#else

// Assume other platforms have gettimeofday().

// TODO(kenton@google.com): Use autoconf to detect availability of

//   gettimeofday().

# define GTEST_HAS_GETTIMEOFDAY_ 1

// cpplint thinks that the header is already included, so we want to

// silence it.

# include   // NOLINT

# include   // NOLINT

#endif  // GTEST_OS_LINUX

#if GTEST_HAS_EXCEPTIONS

# include 

#endif

#if GTEST_CAN_STREAM_RESULTS_

# include   // NOLINT

# include   // NOLINT

#endif

// Indicates that this translation unit is part of Google Test's

// implementation.  It must come before gtest-internal-inl.h is

// included, or there will be a compiler error.  This trick is to

// prevent a user from accidentally including gtest-internal-inl.h in

// his code.

#define GTEST_IMPLEMENTATION_ 1

#include "src/gtest-internal-inl.h"

#undef GTEST_IMPLEMENTATION_

#if GTEST_OS_WINDOWS

# define vsnprintf _vsnprintf

#endif  // GTEST_OS_WINDOWS

namespace testing {

using internal::CountIf;

using internal::ForEach;

using internal::GetElementOr;

using internal::Shuffle;

// Constants.

// A test whose test case name or test name matches this filter is

// disabled and not run.

static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";

// A test case whose name matches this filter is considered a death

// test case and will be run before test cases whose name doesn't

// match this filter.

static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";

// A test filter that matches everything.

static const char kUniversalFilter[] = "*";

// The default output file for XML output.

static const char kDefaultOutputFile[] = "test_detail.xml";

// The environment variable name for the test shard index.

static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";

// The environment variable name for the total number of test shards.

static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";

// The environment variable name for the test shard status file.

static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";

namespace internal {

// The text used in failure messages to indicate the start of the

// stack trace.

const char kStackTraceMarker[] = "\nStack trace:\n";

// g_help_flag is true iff the --help flag or an equivalent form is

// specified on the command line.

bool g_help_flag = false;

}  // namespace internal

static const char* GetDefaultFilter() {

  return kUniversalFilter;

}

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

GTEST_DEFINE_bool_(

    break_on_failure,

    internal::BoolFromGTestEnv("break_on_failure", false),

    "True iff a failed assertion should be a debugger break-point.");

GTEST_DEFINE_bool_(

    catch_exceptions,

    internal::BoolFromGTestEnv("catch_exceptions", true),

    "True iff " GTEST_NAME_

    " should catch exceptions and treat them as test failures.");

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

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

GTEST_DEFINE_bool_(list_tests, false,

                   "List all tests without running them.");

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

GTEST_DEFINE_bool_(

    print_time,

    internal::BoolFromGTestEnv("print_time", true),

    "True iff " GTEST_NAME_

    " should display elapsed time in text output.");

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

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

GTEST_DEFINE_bool_(

    show_internal_stack_frames, false,

    "True iff " GTEST_NAME_ " should include internal stack frames when "

    "printing test failure stack traces.");

GTEST_DEFINE_bool_(

    shuffle,

    internal::BoolFromGTestEnv("shuffle", false),

    "True iff " GTEST_NAME_

    " should randomize tests' order on every run.");

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

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

namespace internal {

// Generates a random number from [0, range), using a Linear

// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater

// than kMaxRange.

UInt32 Random::Generate(UInt32 range) {

  // These constants are the same as are used in glibc's rand(3).

  state_ = (1103515245U*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)

      << "Cannot generate a number in the range [0, 0).";

  GTEST_CHECK_(range <= kMaxRange)

      << "Generation of a number in [0, " << range << ") was requested, "

      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but

  // it's simple, and a linear congruential generator isn't too good

  // to begin with.

  return state_ % range;

}

// GTestIsInitialized() returns true iff the user has initialized

// Google Test.  Useful for catching the user mistake of not initializing

// Google Test before calling RUN_ALL_TESTS().

//

// A user must call testing::InitGoogleTest() to initialize Google

// Test.  g_init_gtest_count is set to the number of times

// InitGoogleTest() has been called.  We don't protect this variable

// under a mutex as it is only accessed in the main thread.

GTEST_API_ int g_init_gtest_count = 0;

static bool GTestIsInitialized() { return g_init_gtest_count != 0; }

// Iterates over a vector of TestCases, keeping a running sum of the

// results of calling a given int-returning method on each.

// Returns the sum.

static int SumOverTestCaseList(const std::vector& case_list,

                               int (TestCase::*method)() const) {

  int sum = 0;

  for (size_t i = 0; i < case_list.size(); i++) {

    sum += (case_list[i]->*method)();

  }

  return sum;

}

// Returns true iff the test case passed.

static bool TestCasePassed(const TestCase* test_case) {

  return test_case->should_run() && test_case->Passed();

}

// Returns true iff the test case failed.

static bool TestCaseFailed(const TestCase* test_case) {

  return test_case->should_run() && test_case->Failed();

}

// Returns true iff test_case contains at least one test that should

// run.

static bool ShouldRunTestCase(const TestCase* test_case) {

  return test_case->should_run();

}

// AssertHelper constructor.

AssertHelper::AssertHelper(TestPartResult::Type type,

                           const char* file,

                           int line,

                           const char* message)

    : data_(new AssertHelperData(type, file, line, message)) {

}

AssertHelper::~AssertHelper() {

  delete data_;

}

// Message assignment, for assertion streaming support.

void AssertHelper::operator=(const Message& message) const {

  UnitTest::GetInstance()->

    AddTestPartResult(data_->type, data_->file, data_->line,

                      AppendUserMessage(data_->message, message),

                      UnitTest::GetInstance()->impl()

                      ->CurrentOsStackTraceExceptTop(1)

                      // Skips the stack frame for this function itself.

                      );  // NOLINT

}

// Mutex for linked pointers.

GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);

// Application pathname gotten in InitGoogleTest.

std::string g_executable_path;

// Returns the current application's name, removing directory path if that

// is present.

FilePath GetCurrentExecutableName() {

  FilePath result;

#if GTEST_OS_WINDOWS

  result.Set(FilePath(g_executable_path).RemoveExtension("exe"));

#else

  result.Set(FilePath(g_executable_path));

#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();

}

// Functions for processing the gtest_output flag.

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

std::string UnitTestOptions::GetOutputFormat() {

  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();

  if (gtest_output_flag == NULL) return std::string("");

  const char* const colon = strchr(gtest_output_flag, ':');

  return (colon == NULL) ?

      std::string(gtest_output_flag) :

      std::string(gtest_output_flag, colon - gtest_output_flag);

}

// Returns the name of the requested output file, or the default if none

// was explicitly specified.

std::string UnitTestOptions::GetAbsolutePathToOutputFile() {

  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();

  if (gtest_output_flag == NULL)

    return "";

  const char* const colon = strchr(gtest_output_flag, ':');

  if (colon == NULL)

    return internal::FilePath::ConcatPaths(

        internal::FilePath(

            UnitTest::GetInstance()->original_working_dir()),

        internal::FilePath(kDefaultOutputFile)).string();

  internal::FilePath output_name(colon + 1);

  if (!output_name.IsAbsolutePath())

    // TODO(wan@google.com): on Windows \some\path is not an absolute

    // path (as its meaning depends on the current drive), yet the

    // following logic for turning it into an absolute path is wrong.

    // Fix it.

    output_name = internal::FilePath::ConcatPaths(

        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),

        internal::FilePath(colon + 1));

  if (!output_name.IsDirectory())

    return output_name.string();

  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(

      output_name, internal::GetCurrentExecutableName(),

      GetOutputFormat().c_str()));

  return result.string();

}

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

bool UnitTestOptions::PatternMatchesString(const char *pattern,

                                           const char *str) {

  switch (*pattern) {

    case '\0':

    case ':':  // Either ':' or '\0' marks the end of the pattern.

      return *str == '\0';

    case '?':  // Matches any single character.

      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);

    case '*':  // Matches any string (possibly empty) of characters.

      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||

          PatternMatchesString(pattern + 1, str);

    default:  // Non-special character.  Matches itself.

      return *pattern == *str &&

          PatternMatchesString(pattern + 1, str + 1);

  }

}

bool UnitTestOptions::MatchesFilter(

    const std::string& name, const char* filter) {

  const char *cur_pattern = filter;

  for (;;) {

    if (PatternMatchesString(cur_pattern, name.c_str())) {

      return true;

    }

    // Finds the next pattern in the filter.

    cur_pattern = strchr(cur_pattern, ':');

    // Returns if no more pattern can be found.

    if (cur_pattern == NULL) {

      return false;

    }

    // Skips the pattern separater (the ':' character).

    cur_pattern++;

  }

}

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

// name and the test name.

bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,

                                        const std::string &test_name) {

  const std::string& full_name = test_case_name + "." + test_name.c_str();

  // Split --gtest_filter at '-', if there is one, to separate into

  // positive filter and negative filter portions

  const char* const p = GTEST_FLAG(filter).c_str();

  const char* const dash = strchr(p, '-');

  std::string positive;

  std::string negative;

  if (dash == NULL) {

    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter

    negative = "";

  } else {

    positive = std::string(p, dash);   // Everything up to the dash

    negative = std::string(dash + 1);  // Everything after the dash

    if (positive.empty()) {

      // Treat '-test1' as the same as '*-test1'

      positive = kUniversalFilter;

    }

  }

  // A filter is a colon-separated list of patterns.  It matches a

  // test if any pattern in it matches the test.

  return (MatchesFilter(full_name, positive.c_str()) &&

          !MatchesFilter(full_name, negative.c_str()));

}

#if GTEST_HAS_SEH

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

int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {

  // Google Test should handle a SEH exception if:

  //   1. the user wants it to, AND

  //   2. this is not a breakpoint exception, AND

  //   3. this is not a C++ exception (VC++ implements them via SEH,

  //      apparently).

  //

  // SEH exception code for C++ exceptions.

  // (see http://support.microsoft.com/kb/185294 for more information).

  const DWORD kCxxExceptionCode = 0xe06d7363;

  bool should_handle = true;

  if (!GTEST_FLAG(catch_exceptions))

    should_handle = false;

  else if (exception_code == EXCEPTION_BREAKPOINT)

    should_handle = false;

  else if (exception_code == kCxxExceptionCode)

    should_handle = false;

  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;

}

#endif  // GTEST_HAS_SEH

}  // namespace internal

// 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. Intercepts only failures from the current thread.

ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(

    TestPartResultArray* result)

    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),

      result_(result) {

  Init();

}

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

ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(

    InterceptMode intercept_mode, TestPartResultArray* result)

    : intercept_mode_(intercept_mode),

      result_(result) {

  Init();

}

void ScopedFakeTestPartResultReporter::Init() {

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();

  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {

    old_reporter_ = impl->GetGlobalTestPartResultReporter();

    impl->SetGlobalTestPartResultReporter(this);

  } else {

    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();

    impl->SetTestPartResultReporterForCurrentThread(this);

  }

}

// The d'tor restores the test part result reporter used by Google Test

// before.

ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();

  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {

    impl->SetGlobalTestPartResultReporter(old_reporter_);

  } else {

    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);

  }

}

// Increments the test part result count and remembers the result.

// This method is from the TestPartResultReporterInterface interface.

void ScopedFakeTestPartResultReporter::ReportTestPartResult(

    const TestPartResult& result) {

  result_->Append(result);

}

namespace internal {

// Returns the type ID of ::testing::Test.  We should always call this

// instead of GetTypeId< ::testing::Test>() to get the type ID of

// testing::Test.  This is to work around a suspected linker bug when

// using Google Test as a framework on Mac OS X.  The bug causes

// GetTypeId< ::testing::Test>() to return different values depending

// on whether the call is from the Google Test framework itself or

// from user test code.  GetTestTypeId() is guaranteed to always

// return the same value, as it always calls GetTypeId<>() from the

// gtest.cc, which is within the Google Test framework.

TypeId GetTestTypeId() {

  return GetTypeId();

}

// The value of GetTestTypeId() as seen from within the Google Test

// library.  This is solely for testing GetTestTypeId().

extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();

// This predicate-formatter checks that 'results' contains a test part

// failure of the given type and that the failure message contains the

// given substring.

AssertionResult HasOneFailure(const char* /* results_expr */,

                              const char* /* type_expr */,

                              const char* /* substr_expr */,

                              const TestPartResultArray& results,

                              TestPartResult::Type type,

                              const string& substr) {

  const std::string expected(type == TestPartResult::kFatalFailure ?

                        "1 fatal failure" :

                        "1 non-fatal failure");

  Message msg;

  if (results.size() != 1) {

    msg << "Expected: " << expected << "\n"

        << "  Actual: " << results.size() << " failures";

    for (int i = 0; i < results.size(); i++) {

      msg << "\n" << results.GetTestPartResult(i);

    }

    return AssertionFailure() << msg;

  }

  const TestPartResult& r = results.GetTestPartResult(0);

  if (r.type() != type) {

    return AssertionFailure() << "Expected: " << expected << "\n"

                              << "  Actual:\n"

                              << r;

  }

  if (strstr(r.message(), substr.c_str()) == NULL) {

    return AssertionFailure() << "Expected: " << expected << " containing \""

                              << substr << "\"\n"

                              << "  Actual:\n"

                              << r;

  }

  return AssertionSuccess();

}

// The constructor of SingleFailureChecker remembers where to look up

// test part results, what type of failure we expect, and what

// substring the failure message should contain.

SingleFailureChecker:: SingleFailureChecker(

    const TestPartResultArray* results,

    TestPartResult::Type type,

    const string& substr)

    : results_(results),

      type_(type),

      substr_(substr) {}

// The destructor of SingleFailureChecker verifies that the given

// TestPartResultArray contains exactly one failure that has the given

// type and contains the given substring.  If that's not the case, a

// non-fatal failure will be generated.

SingleFailureChecker::~SingleFailureChecker() {

  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);

}

DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(

    UnitTestImpl* unit_test) : unit_test_(unit_test) {}

void DefaultGlobalTestPartResultReporter::ReportTestPartResult(

    const TestPartResult& result) {

  unit_test_->current_test_result()->AddTestPartResult(result);

  unit_test_->listeners()->repeater()->OnTestPartResult(result);

}

DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(

    UnitTestImpl* unit_test) : unit_test_(unit_test) {}

void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(

    const TestPartResult& result) {

  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);

}

// Returns the global test part result reporter.

TestPartResultReporterInterface*

UnitTestImpl::GetGlobalTestPartResultReporter() {

  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);

  return global_test_part_result_repoter_;

}

// Sets the global test part result reporter.

void UnitTestImpl::SetGlobalTestPartResultReporter(

    TestPartResultReporterInterface* reporter) {

  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);

  global_test_part_result_repoter_ = reporter;

}

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

TestPartResultReporterInterface*

UnitTestImpl::GetTestPartResultReporterForCurrentThread() {

  return per_thread_test_part_result_reporter_.get();

}

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

void UnitTestImpl::SetTestPartResultReporterForCurrentThread(

    TestPartResultReporterInterface* reporter) {

  per_thread_test_part_result_reporter_.set(reporter);

}

// Gets the number of successful test cases.

int UnitTestImpl::successful_test_case_count() const {

  return CountIf(test_cases_, TestCasePassed);

}

// Gets the number of failed test cases.

int UnitTestImpl::failed_test_case_count() const {

  return CountIf(test_cases_, TestCaseFailed);

}

// Gets the number of all test cases.

int UnitTestImpl::total_test_case_count() const {

  return static_cast(test_cases_.size());

}

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

// that should run.

int UnitTestImpl::test_case_to_run_count() const {

  return CountIf(test_cases_, ShouldRunTestCase);

}

// Gets the number of successful tests.

int UnitTestImpl::successful_test_count() const {

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

}

// Gets the number of failed tests.

int UnitTestImpl::failed_test_count() const {

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

}

// Gets the number of disabled tests that will be reported in the XML report.

int UnitTestImpl::reportable_disabled_test_count() const {

  return SumOverTestCaseList(test_cases_,

                             &TestCase::reportable_disabled_test_count);

}

// Gets the number of disabled tests.

int UnitTestImpl::disabled_test_count() const {

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

}

// Gets the number of tests to be printed in the XML report.

int UnitTestImpl::reportable_test_count() const {

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

}

// Gets the number of all tests.

int UnitTestImpl::total_test_count() const {

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

}

// Gets the number of tests that should run.

int UnitTestImpl::test_to_run_count() const {

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

}

// Returns the current OS stack trace as an std::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

// count against the number of frames to be included.

//

// For example, if Foo() calls Bar(), which in turn calls

// CurrentOsStackTraceExceptTop(1), Foo() will be included in the

// trace but Bar() and CurrentOsStackTraceExceptTop() won't.

std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {

  (void)skip_count;

  return "";

}

// Returns the current time in milliseconds.

TimeInMillis GetTimeInMillis() {

#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)

  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.

  // http://analogous.blogspot.com/2005/04/epoch.html

  const TimeInMillis kJavaEpochToWinFileTimeDelta =

    static_cast(116444736UL) * 100000UL;

  const DWORD kTenthMicrosInMilliSecond = 10000;

  SYSTEMTIME now_systime;

  FILETIME now_filetime;

  ULARGE_INTEGER now_int64;

  // TODO(kenton@google.com): Shouldn't this just use

  //   GetSystemTimeAsFileTime()?

  GetSystemTime(&now_systime);

  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {

    now_int64.LowPart = now_filetime.dwLowDateTime;

    now_int64.HighPart = now_filetime.dwHighDateTime;

    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -

      kJavaEpochToWinFileTimeDelta;

    return now_int64.QuadPart;

  }

  return 0;

#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_

  __timeb64 now;

# ifdef _MSC_VER

  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996

  // (deprecated function) there.

  // TODO(kenton@google.com): Use GetTickCount()?  Or use

  //   SystemTimeToFileTime()

#  pragma warning(push)          // Saves the current warning state.

#  pragma warning(disable:4996)  // Temporarily disables warning 4996.

  _ftime64(&now);

#  pragma warning(pop)           // Restores the warning state.

# else

  _ftime64(&now);

# endif  // _MSC_VER

  return static_cast(now.time) * 1000 + now.millitm;

#elif GTEST_HAS_GETTIMEOFDAY_

  struct timeval now;

  gettimeofday(&now, NULL);

  return static_cast(now.tv_sec) * 1000 + now.tv_usec / 1000;

#else

# error "Don't know how to get the current time on your system."

#endif

}

// Utilities

// class String.

#if GTEST_OS_WINDOWS_MOBILE

// Creates a UTF-16 wide string from the given ANSI string, allocating

// memory using new. The caller is responsible for deleting the return

// value using delete[]. Returns the wide string, or NULL if the

// input is NULL.

LPCWSTR String::AnsiToUtf16(const char* ansi) {

  if (!ansi) return NULL;

  const int length = strlen(ansi);

  const int unicode_length =

      MultiByteToWideChar(CP_ACP, 0, ansi, length,

                          NULL, 0);

  WCHAR* unicode = new WCHAR[unicode_length + 1];

  MultiByteToWideChar(CP_ACP, 0, ansi, length,

                      unicode, unicode_length);

  unicode[unicode_length] = 0;

  return unicode;

}

// Creates an ANSI string from the given wide string, allocating

// memory using new. The caller is responsible for deleting the return

// value using delete[]. Returns the ANSI string, or NULL if the

// input is NULL.

const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {

  if (!utf16_str) return NULL;

  const int ansi_length =

      WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,

                          NULL, 0, NULL, NULL);

  char* ansi = new char[ansi_length + 1];

  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,

                      ansi, ansi_length, NULL, NULL);

  ansi[ansi_length] = 0;

  return ansi;

}

#endif  // GTEST_OS_WINDOWS_MOBILE

// Compares two C strings.  Returns true iff they have the same content.

//

// Unlike strcmp(), this function can handle NULL argument(s).  A NULL

// C string is considered different to any non-NULL C string,

// including the empty string.

bool String::CStringEquals(const char * lhs, const char * rhs) {

  if ( lhs == NULL ) return rhs == NULL;

  if ( rhs == NULL ) return false;

  return strcmp(lhs, rhs) == 0;

}

#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING

// Converts an array of wide chars to a narrow string using the UTF-8

// encoding, and streams the result to the given Message object.

static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,

                                     Message* msg) {

  for (size_t i = 0; i != length; ) {  // NOLINT

    if (wstr[i] != L'\0') {

      *msg << WideStringToUtf8(wstr + i, static_cast(length - i));

      while (i != length && wstr[i] != L'\0')

        i++;

    } else {

      *msg << '\0';

      i++;

    }

  }

}

#endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING

}  // namespace internal

// Constructs an empty Message.

// We allocate the stringstream separately because otherwise each use of

// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's

// stack frame leading to huge stack frames in some cases; gcc does not reuse

// the stack space.

Message::Message() : ss_(new ::std::stringstream) {

  // By default, we want there to be enough precision when printing

  // a double to a Message.

  *ss_ << std::setprecision(std::numeric_limits::digits10 + 2);

}

// These two overloads allow streaming a wide C string to a Message

// using the UTF-8 encoding.

Message& Message::operator <<(const wchar_t* wide_c_str) {

  return *this << internal::String::ShowWideCString(wide_c_str);

}

Message& Message::operator <<(wchar_t* wide_c_str) {

  return *this << internal::String::ShowWideCString(wide_c_str);

}

#if GTEST_HAS_STD_WSTRING

// Converts the given wide string to a narrow string using the UTF-8

// encoding, and streams the result to this Message object.

Message& Message::operator <<(const ::std::wstring& wstr) {

  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);

  return *this;

}

#endif  // GTEST_HAS_STD_WSTRING

#if GTEST_HAS_GLOBAL_WSTRING

// Converts the given wide string to a narrow string using the UTF-8

// encoding, and streams the result to this Message object.

Message& Message::operator <<(const ::wstring& wstr) {

  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);

  return *this;

}

#endif  // GTEST_HAS_GLOBAL_WSTRING

// Gets the text streamed to this object so far as an std::string.

// Each '\0' character in the buffer is replaced with "\\0".

std::string Message::GetString() const {

  return internal::StringStreamToString(ss_.get());

}

// AssertionResult constructors.

// Used in EXPECT_TRUE/FALSE(assertion_result).

AssertionResult::AssertionResult(const AssertionResult& other)

    : success_(other.success_),

      message_(other.message_.get() != NULL ?

               new ::std::string(*other.message_) :

               static_cast< ::std::string*>(NULL)) {

}

// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.

AssertionResult AssertionResult::operator!() const {

  AssertionResult negation(!success_);

  if (message_.get() != NULL)

    negation << *message_;

  return negation;

}

// Makes a successful assertion result.

AssertionResult AssertionSuccess() {

  return AssertionResult(true);

}

// Makes a failed assertion result.

AssertionResult AssertionFailure() {

  return AssertionResult(false);

}

// Makes a failed assertion result with the given failure message.

// Deprecated; use AssertionFailure() << message.

AssertionResult AssertionFailure(const Message& message) {

  return AssertionFailure() << message;

}

namespace internal {

// Constructs and returns the message for an equality assertion

// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.

//

// The first four parameters are the expressions used in the assertion

// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)

// where foo is 5 and bar is 6, we have:

//

//   expected_expression: "foo"

//   actual_expression:   "bar"

//   expected_value:      "5"

//   actual_value:        "6"

//

// The ignoring_case parameter is true iff the assertion is a

// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will

// be inserted into the message.

AssertionResult EqFailure(const char* expected_expression,

                          const char* actual_expression,

                          const std::string& expected_value,

                          const std::string& actual_value,

                          bool ignoring_case) {

  Message msg;

  msg << "Value of: " << actual_expression;

  if (actual_value != actual_expression) {

    msg << "\n  Actual: " << actual_value;

  }

  msg << "\nExpected: " << expected_expression;

  if (ignoring_case) {

    msg << " (ignoring case)";

  }

  if (expected_value != expected_expression) {

    msg << "\nWhich is: " << expected_value;

  }

  return AssertionFailure() << msg;

}

// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.

std::string GetBoolAssertionFailureMessage(

    const AssertionResult& assertion_result,

    const char* expression_text,

    const char* actual_predicate_value,

    const char* expected_predicate_value) {

  const char* actual_message = assertion_result.message();

  Message msg;

  msg << "Value of: " << expression_text

      << "\n  Actual: " << actual_predicate_value;

  if (actual_message[0] != '\0')

    msg << " (" << actual_message << ")";

  msg << "\nExpected: " << expected_predicate_value;

  return msg.GetString();

}

// Helper function for implementing ASSERT_NEAR.

AssertionResult DoubleNearPredFormat(const char* expr1,

                                     const char* expr2,

                                     const char* abs_error_expr,

                                     double val1,

                                     double val2,

                                     double abs_error) {

  const double diff = fabs(val1 - val2);

  if (diff <= abs_error) return AssertionSuccess();

  // TODO(wan): do not print the value of an expression if it's

  // already a literal.

  return AssertionFailure()

      << "The difference between " << expr1 << " and " << expr2

      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"

      << expr1 << " evaluates to " << val1 << ",\n"

      << expr2 << " evaluates to " << val2 << ", and\n"

      << abs_error_expr << " evaluates to " << abs_error << ".";

}

// Helper template for implementing FloatLE() and DoubleLE().

template 

AssertionResult FloatingPointLE(const char* expr1,

                                const char* expr2,

                                RawType val1,

                                RawType val2) {

  // Returns success if val1 is less than val2,

  if (val1 < val2) {

    return AssertionSuccess();

  }

  // or if val1 is almost equal to val2.

  const FloatingPoint lhs(val1), rhs(val2);

  if (lhs.AlmostEquals(rhs)) {

    return AssertionSuccess();

  }

  // Note that the above two checks will both fail if either val1 or

  // val2 is NaN, as the IEEE floating-point standard requires that

  // any predicate involving a NaN must return false.

  ::std::stringstream val1_ss;

  val1_ss << std::setprecision(std::numeric_limits::digits10 + 2)

          << val1;

  ::std::stringstream val2_ss;

  val2_ss << std::setprecision(std::numeric_limits::digits10 + 2)

          << val2;

  return AssertionFailure()

      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"

      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "

      << StringStreamToString(&val2_ss);

}

}  // namespace internal

// Asserts that val1 is less than, or almost equal to, val2.  Fails

// otherwise.  In particular, it fails if either val1 or val2 is NaN.

AssertionResult FloatLE(const char* expr1, const char* expr2,

                        float val1, float val2) {

  return internal::FloatingPointLE(expr1, expr2, val1, val2);

}

// Asserts that val1 is less than, or almost equal to, val2.  Fails

// otherwise.  In particular, it fails if either val1 or val2 is NaN.

AssertionResult DoubleLE(const char* expr1, const char* expr2,

                         double val1, double val2) {

  return internal::FloatingPointLE(expr1, expr2, val1, val2);

}

namespace internal {

// The helper function for {ASSERT|EXPECT}_EQ with int or enum

// arguments.

AssertionResult CmpHelperEQ(const char* expected_expression,

                            const char* actual_expression,

                            BiggestInt expected,

                            BiggestInt actual) {

  if (expected == actual) {

    return AssertionSuccess();

  }

  return EqFailure(expected_expression,