/thirdparty/breakpad/third_party/protobuf/protobuf/gtest/src/gtest.cc
C++ | 1800 lines | 1098 code | 259 blank | 443 comment | 191 complexity | 8de68a35c745eae12a68802b12569879 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, GPL-3.0, GPL-2.0
- // 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 <ctype.h>
- #include <math.h>
- #include <stdarg.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <wchar.h>
- #include <wctype.h>
- #include <algorithm>
- #include <ostream>
- #include <sstream>
- #include <vector>
- #if GTEST_OS_LINUX
- // TODO(kenton@google.com): Use autoconf to detect availability of
- // gettimeofday().
- #define GTEST_HAS_GETTIMEOFDAY_ 1
- #include <fcntl.h>
- #include <limits.h>
- #include <sched.h>
- // Declares vsnprintf(). This header is not available on Windows.
- #include <strings.h>
- #include <sys/mman.h>
- #include <sys/time.h>
- #include <unistd.h>
- #include <string>
- #include <vector>
- #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
- // On z/OS we additionally need strings.h for strcasecmp.
- #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
- // 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 <sys/time.h> // NOLINT
- #endif // GTEST_OS_WINDOWS_MINGW
- // cpplint thinks that the header is already included, so we want to
- // silence it.
- #include <windows.h> // 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 <sys/time.h> // NOLINT
- #include <unistd.h> // NOLINT
- #endif // GTEST_OS_LINUX
- #if GTEST_HAS_EXCEPTIONS
- #include <stdexcept>
- #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
- 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", false),
- "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 xterm, xterm-color, xterm-256color, linux or cygwin.");
- GTEST_DEFINE_string_(
- filter,
- internal::StringFromGTestEnv("filter", kUniversalFilter),
- "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_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.
- 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<TestCase*>& 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_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
- // Application pathname gotten in InitGoogleTest.
- 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.
- String UnitTestOptions::GetOutputFormat() {
- const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
- if (gtest_output_flag == NULL) return String("");
- const char* const colon = strchr(gtest_output_flag, ':');
- return (colon == NULL) ?
- String(gtest_output_flag) :
- String(gtest_output_flag, colon - gtest_output_flag);
- }
- // Returns the name of the requested output file, or the default if none
- // was explicitly specified.
- String UnitTestOptions::GetAbsolutePathToOutputFile() {
- const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
- if (gtest_output_flag == NULL)
- return String("");
- const char* const colon = strchr(gtest_output_flag, ':');
- if (colon == NULL)
- return String(internal::FilePath::ConcatPaths(
- internal::FilePath(
- UnitTest::GetInstance()->original_working_dir()),
- internal::FilePath(kDefaultOutputFile)).ToString() );
- 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.ToString();
- internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
- output_name, internal::GetCurrentExecutableName(),
- GetOutputFormat().c_str()));
- return result.ToString();
- }
- // 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 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++;
- }
- }
- // TODO(keithray): move String function implementations to gtest-string.cc.
- // Returns true iff the user-specified filter matches the test case
- // name and the test name.
- bool UnitTestOptions::FilterMatchesTest(const String &test_case_name,
- const String &test_name) {
- const String& full_name = String::Format("%s.%s",
- test_case_name.c_str(),
- 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, '-');
- String positive;
- String negative;
- if (dash == NULL) {
- positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter
- negative = String("");
- } else {
- positive = String(p, dash - p); // Everything up to the dash
- negative = 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_OS_WINDOWS
- // 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 an exception if:
- // 1. the user wants it to, AND
- // 2. this is not a breakpoint exception.
- return (GTEST_FLAG(catch_exceptions) &&
- exception_code != EXCEPTION_BREAKPOINT) ?
- EXCEPTION_EXECUTE_HANDLER :
- EXCEPTION_CONTINUE_SEARCH;
- }
- #endif // GTEST_OS_WINDOWS
- } // 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<Test>();
- }
- // 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 char* substr) {
- const 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) {
- msg << "Expected: " << expected << "\n"
- << " Actual:\n"
- << r;
- return AssertionFailure(msg);
- }
- if (strstr(r.message(), substr) == NULL) {
- msg << "Expected: " << expected << " containing \""
- << substr << "\"\n"
- << " Actual:\n"
- << r;
- return AssertionFailure(msg);
- }
- 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 char* 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_.c_str());
- }
- 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<int>(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.
- int UnitTestImpl::disabled_test_count() const {
- return SumOverTestCaseList(test_cases_, &TestCase::disabled_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 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
- // 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.
- String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
- (void)skip_count;
- return String("");
- }
- // 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<TimeInMillis>(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<TimeInMillis>(now.time) * 1000 + now.millitm;
- #elif GTEST_HAS_GETTIMEOFDAY_
- struct timeval now;
- gettimeofday(&now, NULL);
- return static_cast<TimeInMillis>(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
- // Returns the input enclosed in double quotes if it's not NULL;
- // otherwise returns "(null)". For example, "\"Hello\"" is returned
- // for input "Hello".
- //
- // This is useful for printing a C string in the syntax of a literal.
- //
- // Known issue: escape sequences are not handled yet.
- String String::ShowCStringQuoted(const char* c_str) {
- return c_str ? String::Format("\"%s\"", c_str) : String("(null)");
- }
- // Copies at most length characters from str into a newly-allocated
- // piece of memory of size length+1. The memory is allocated with new[].
- // A terminating null byte is written to the memory, and a pointer to it
- // is returned. If str is NULL, NULL is returned.
- static char* CloneString(const char* str, size_t length) {
- if (str == NULL) {
- return NULL;
- } else {
- char* const clone = new char[length + 1];
- posix::StrNCpy(clone, str, length);
- clone[length] = '\0';
- return clone;
- }
- }
- // Clones a 0-terminated C string, allocating memory using new. The
- // caller is responsible for deleting[] the return value. Returns the
- // cloned string, or NULL if the input is NULL.
- const char * String::CloneCString(const char* c_str) {
- return (c_str == NULL) ?
- NULL : CloneString(c_str, strlen(c_str));
- }
- #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) {
- // TODO(wan): consider allowing a testing::String object to
- // contain '\0'. This will make it behave more like std::string,
- // and will allow ToUtf8String() to return the correct encoding
- // for '\0' s.t. we can get rid of the conditional here (and in
- // several other places).
- for (size_t i = 0; i != length; ) { // NOLINT
- if (wstr[i] != L'\0') {
- *msg << WideStringToUtf8(wstr + i, static_cast<int>(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
- #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
- namespace internal {
- // Formats a value to be used in a failure message.
- // For a char value, we print it as a C++ char literal and as an
- // unsigned integer (both in decimal and in hexadecimal).
- String FormatForFailureMessage(char ch) {
- const unsigned int ch_as_uint = ch;
- // A String object cannot contain '\0', so we print "\\0" when ch is
- // '\0'.
- return String::Format("'%s' (%u, 0x%X)",
- ch ? String::Format("%c", ch).c_str() : "\\0",
- ch_as_uint, ch_as_uint);
- }
- // For a wchar_t value, we print it as a C++ wchar_t literal and as an
- // unsigned integer (both in decimal and in hexidecimal).
- String FormatForFailureMessage(wchar_t wchar) {
- // The C++ standard doesn't specify the exact size of the wchar_t
- // type. It just says that it shall have the same size as another
- // integral type, called its underlying type.
- //
- // Therefore, in order to print a wchar_t value in the numeric form,
- // we first convert it to the largest integral type (UInt64) and
- // then print the converted value.
- //
- // We use streaming to print the value as "%llu" doesn't work
- // correctly with MSVC 7.1.
- const UInt64 wchar_as_uint64 = wchar;
- Message msg;
- // A String object cannot contain '\0', so we print "\\0" when wchar is
- // L'\0'.
- char buffer[32]; // CodePointToUtf8 requires a buffer that big.
- msg << "L'"
- << (wchar ? CodePointToUtf8(static_cast<UInt32>(wchar), buffer) : "\\0")
- << "' (" << wchar_as_uint64 << ", 0x" << ::std::setbase(16)
- << wchar_as_uint64 << ")";
- return msg.GetString();
- }
- } // namespace internal
- // AssertionResult constructors.
- // Used in EXPECT_TRUE/FALSE(assertion_result).
- AssertionResult::AssertionResult(const AssertionResult& other)
- : success_(other.success_),
- message_(other.message_.get() != NULL ?
- new internal::String(*other.message_) :
- static_cast<internal::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 String& expected_value,
- const 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.
- 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.
- Message msg;
- msg << "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 << ".";
- return AssertionFailure(msg);
- }
- // Helper template for implementing FloatLE() and DoubleLE().
- template <typename RawType>
- 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<RawType> 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.
- StrStream val1_ss;
- val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
- << val1;
- StrStream val2_ss;
- val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
- << val2;
- Message msg;
- msg << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
- << " Actual: " << StrStreamToString(&val1_ss) << " vs "
- << StrStreamToString(&val2_ss);
- return AssertionFailure(msg);
- }
- } // 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<float>(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<double>(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,
- actual_expression,
- FormatForComparisonFailureMessage(expected, actual),
- FormatForComparisonFailureMessage(actual, expected),
- false);
- }
- // A macro for implementing the helper functions needed to implement
- // ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here
- // just to avoid copy-and-paste of similar code.
- #define GTEST_IMPL_CMP_HELPER_(op_name, op)\
- AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
- BiggestInt val1, BiggestInt val2) {\
- if (val1 op val2) {\
- return AssertionSuccess();\
- } else {\
- Message msg;\
- msg << "Expected: (" << expr1 << ") " #op " (" << expr2\
- << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
- << " vs " << FormatForComparisonFailureMessage(val2, val1);\
- return AssertionFailure(msg);\
- }\
- }
- // Implements the helper function for {ASSERT|EXPECT}_NE with int or
- // enum arguments.
- GTEST_IMPL_CMP_HELPER_(NE, !=)
- // Implements the helper function for {ASSERT|EXPECT}_LE with int or
- // enum arguments.
- GTEST_IMPL_CMP_HELPER_(LE, <=)
- // Implements the helper function for {ASSERT|EXPECT}_LT with int or
- // enum arguments.
- GTEST_IMPL_CMP_HELPER_(LT, < )
- // Implements the helper function for {ASSERT|EXPECT}_GE with int or
- // enum arguments.
- GTEST_IMPL_CMP_HELPER_(GE, >=)
- // Implements the helper function for {ASSERT|EXPECT}_GT with int or
- // enum arguments.
- GTEST_IMPL_CMP_HELPER_(GT, > )
- #undef GTEST_IMPL_CMP_HELPER_
- // The helper function for {ASSERT|EXPECT}_STREQ.
- AssertionResult CmpHelperSTREQ(const char* expected_expression,
- const char* actual_expression,
- const char* expected,
- const char* actual) {
- if (String::CStringEquals(expected, actual)) {
- return AssertionSuccess();
- }
- return EqFailure(expected_expression,
- actual_expression,
- String::ShowCStringQuoted(expected),
- String::ShowCStringQuoted(actual),
- false);
- }
- // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
- AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
- const char* actual_expression,
- const char* expected,
- const char* actual) {
- if (String::CaseInsensitiveCStringEquals(expected, actual)) {
- return AssertionSuccess();
- }
- return EqFailure(expected_expression,
- actual_expression,
- String::ShowCStringQuoted(expected),
- String::ShowCStringQuoted(actual),
- true);
- }
- // The helper function for {ASSERT|EXPECT}_STRNE.
- AssertionResult CmpHelperSTRNE(const char* s1_expression,
- const char* s2_expression,
- const char* s1,
- const char* s2) {
- if (!String::CStringEquals(s1, s2)) {
- return AssertionSuccess();
- } else {
- Message msg;
- msg << "Expected: (" << s1_expression << ") != ("
- << s2_expression << "), actual: \""
- << s1 << "\" vs \"" << s2 << "\"";
- return AssertionFailure(msg);
- }
- }
- // The helper function for {ASSERT|EXPECT}_STRCASENE.
- AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
- const char* s2_expression,
- const char* s1,
- const char* s2) {
- if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
- return AssertionSuccess();
- } else {
- Message msg;
- msg << "Expected: (" << s1_expression << ") != ("
- << s2_expression << ") (ignoring case), actual: \""
- << s1 << "\" vs \"" << s2 << "\"";
- return AssertionFailure(msg);
- }
- }
- } // namespace internal
- namespace {
- // Helper functions for implementing IsSubString() and IsNotSubstring().
- // This group of overloaded functions return true iff needle is a
- // substring of haystack. NULL is considered a substring of itself
- // only.
- bool IsSubstringPred(const char* needle, const char* haystack) {
- if (needle == NULL || haystack == NULL)
- return needle == haystack;
- return strstr(haystack, needle) != NULL;
- }
- bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
- if (needle == NULL || haystack == NULL)
- return needle == haystack;
- return wcsstr(haystack, needle) != NULL;
- }
- // StringType here can be either ::std::string or ::std::wstring.
- template <typename StringType>
- bool IsSubstringPred(const StringType& needle,
- const StringType& haystack) {
- return haystack.find(needle) != StringType::npos;
- }
- // This function implements either IsSubstring() or IsNotSubstring(),
- // depending on the value of the expected_to_be_substring parameter.
- // StringType here can be const char*, const wchar_t*, ::std::string,
- // or ::std::wstring.
- template <typename StringType>
- AssertionResult IsSubstringImpl(
- bool expected_to_be_substring,
- const char* needle_expr, const char* haystack_expr,
- const StringType& needle, const StringType& haystack) {
- if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
- return AssertionSuccess();
- const bool is_wide_string = sizeof(needle[0]) > 1;
- const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
- return AssertionFailure(
- Message()
- << "Value of: " << needle_expr << "\n"
- << " Actual: " << begin_string_quote << needle << "\"\n"
- << "Expected: " << (expected_to_be_substring ? "" : "not ")
- << "a substring of " << haystack_expr << "\n"
- << "Which is: " << begin_string_quote << haystack << "\"");
- }
- } // namespace
- // IsSubstring() and IsNotSubstring() check whether needle is a
- // substring of haystack (NULL is considered a substring of itself
- // only), and return an appropriate error message when they fail.
- AssertionResult IsSubstring(
- const char* needle_expr, const char* haystack_expr,
- const char* needle, const char* haystack) {
- return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
- }
- AssertionResult IsSubstring(
- const char* needle_expr, const char* haystack_expr,
- const wchar_t* needle, const wchar_t* haystack) {
- return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
- }
- AssertionResult IsNotSubstring(
- const char* needle_expr, const char* haystack_expr,
- const char* needle, const char* haystack) {
- return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
- }
- AssertionResult IsNotSubstring(
- const char* needle_expr, const char* haystack_expr,
- const wchar_t* needle, const wchar_t* haystack) {
- return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
- }
- AssertionResult IsSubstring(
- const char* needle_expr, const char* haystack_expr,
- const ::std::string& needle, const ::std::string& haystack) {
- return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
- }
- AssertionResult IsNotSubstring(
- const char* needle_expr, const char* haystack_expr,
- const ::std::string& needle, const ::std::string& haystack) {
- return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
- }
- #if GTEST_HAS_STD_WSTRING
- AssertionResult IsSubstring(
- const char* needle_expr, const char* haystack_expr,
- const ::std::wstring& needle, const ::std::wstring& haystack) {
- return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
- }
- AssertionResult IsNotSubstring(
- const char* needle_expr, const char* haystack_expr,
- const ::std::wstring& needle, const ::std::wstring& haystack) {
- return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
- }
- #endif // GTEST_HAS_STD_WSTRING
- namespace internal {
- #if GTEST_OS_WINDOWS
- namespace {
- // Helper function for IsHRESULT{SuccessFailure} predicates
- AssertionResult HRESULTFailureHelper(const char* expr,
- const char* expected,
- long hr) { // NOLINT
- #if GTEST_OS_WINDOWS_MOBILE
- // Windows CE doesn't support FormatMessage.
- const char error_text[] = "";
- #else
- // Looks up the human-readable system message for the HRESULT code
- // and since we're not passing any params to FormatMessage, we don't
- // want inserts expanded.
- const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
- FORMAT_MESSAGE_IGNORE_INSERTS;
- const DWORD kBufSize = 4096; // String::Format can't exceed this length.
- // Gets the system's human readable message string for this HRESULT.
- char error_text[kBufSize] = { '\0' };
- DWORD message_length = ::FormatMessageA(kFlags,
- 0, // no source, we're asking system
- hr, // the error
- 0, // no line width restrictions
- error_text, // output buffer
- kBufSize, // buf size
- NULL); // no arguments for inserts
- // Trims tailing white space (FormatMessage leaves a trailing cr-lf)
- for (; message_length && isspace(error_text[message_length - 1]);
- --message_length) {
- error_text[message_length - 1] = '\0';
- }
- #endif // GTEST_OS_WINDOWS_MOBILE
- const String error_hex(String::Format("0x%08X ", hr));
- Message msg;
- msg << "Expected: " << expr << " " << expected << ".\n"
- << " Actual: " << error_hex << error_text << "\n";
- return ::testing::AssertionFailure(msg);
- }
- } // namespace
- AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT
- if (SUCCEEDED(hr)) {
- return AssertionSuccess();
- }
- return HRESULTFailureHelper(expr, "succeeds", hr);
- }
- AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT
- if (FAILED(hr)) {
- return AssertionSuccess();
- }
- return HRESULTFailureHelper(expr, "fails", hr);
- }
- #endif // GTEST_OS_WINDOWS
- // Utility functions for encoding Unicode text (wide strings) in
- // UTF-8.
- // A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
- // like this:
- //
- // Code-point length Encoding
- // 0 - 7 bits 0xxxxxxx
- // 8 - 11 bits 110xxxxx 10xxxxxx
- // 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx
- // 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- // The maximum code-point a one-byte UTF-8 sequence can represent.
- const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1;
- // The maximum code-point a two-byte UTF-8 sequence can represent.
- const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
- // The maximum code-point a three-byte UTF-8 sequence can represent.
- const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
- // The maximum code-point a four-byte UTF-8 sequence can represent.
- const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1;
- // Chops off the n lowest bits from a bit pattern. Returns the n
- // lowest bits. As a side effect, the original bit pattern will be
- // shifted to the right by n bits.
- inline UInt32 ChopLowBits(UInt32* bits, int n) {
- const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
- *bits >>= n;
- return low_bits;
- }
- // Converts a Unicode code point to a narrow string in UTF-8 encoding.
- // code_point parameter is of type UInt32 because wchar_t may not be
- // wide enough to contain a code point.
- // The output buffer str must containt at least 32 characters.
- // The function returns the address of the output buffer.
- // If the code_point is not a valid Unicode code point
- // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
- // as '(Invalid Unicode 0xXXXXXXXX)'.
- char* CodePointToUtf8(UInt32 code_point, char* str) {
- if (code_point <= kMaxCodePoint1) {
- str[1] = '\0';
- str[0] = static_cast<char>(code_point); // 0xxxxxxx
- } else if (code_point <= kMaxCodePoint2) {
- str[2] = '\0';
- str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
- str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx
- } else if (code_point <= kMaxCodePoint3) {
- str[3] = '\0';
- str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
- str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
- str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx
- } else if (code_point <= kMaxCodePoint4) {
- str[4] = '\0';
- str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
- str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
- str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
- str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx
- } else {
- // The longest string String::Format can produce when invoked
- // with these parameters is 28 character long (not including
- // the terminating nul character). We are asking for 32 character
- // buffer just in case. This is also enough for strncpy to
- // null-terminate the destination string.
- posix::StrNCpy(
- str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32);
- str[31] = '\0'; // Makes sure no change in the format to strncpy leaves
- // the result unterminated.
- }
- return str;
- }
- // The following two functions only make sense if the the system
- // uses UTF-16 for wide string encoding. All supported systems
- // with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
- // Determines if the arguments constitute UTF-16 surrogate pair
- // and thus should be combined into a single Unicode code point
- // using CreateCodePointFromUtf16SurrogatePair.
- inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
- return sizeof(wchar_t) == 2 &&
- (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
- }
- // Creates a Unicode code point from UTF16 surrogate pair.
- inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
- wchar_t second) {
- const UInt32 mask = (1 << 10) - 1;
- return (sizeof(wchar_t) == 2) ?
- (((first & mask) << 10) | (second & mask)) + 0x10000 :
- // This function should not be called when the condition is
- // false, but we provide a sensible default in case it is.
- static_cast<UInt32>(first);
- }
- // Converts a wide string to a narrow string in UTF-8 encoding.
- // The wide string is assumed to have the following encoding:
- // UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
- // UTF-32 if sizeof(wchar_t) == 4 (on Linux)
- // Parameter str points to a null-terminated wide string.
- // Parameter num_chars may additionally limit the number
- // of wchar_t characters processed. -1 is used when the entire string
- // should be processed.
- // If the string contains code points that are not valid Unicode code points
- // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
- // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
- // and contains invalid UTF-16 surrogate pairs, values in those pairs
- // will be encoded as individual Unicode characters from Basic Normal Plane.
- String WideStringToUtf8(const wchar_t* str, int num_chars) {
- if (num_chars == -1)
- num_chars = static_cast<int>(wcslen(str));
- StrStream stream;
- for (int i = 0; i < num_chars; ++i) {
- UInt32 unicode_code_point;
- if (str[i] == L'\0') {
- break;
- } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
- unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
- str[i + 1]);
- i++;
- } else {
- unicode_code_point = static_cast<UInt32>(str[i]);
- }
- char buffer[32]; // CodePointToUtf8 requires a buffer this big.
- stream << CodePointToUtf8(unicode_code_point, buffer);
- }
- return StrStreamToString(&stream);
- }
- // Converts a wide C string to a String using the UTF-8 encoding.
- // NULL will be converted to "(null)".
- String String::ShowWideCString(const wchar_t * wide_c_str) {
- if (wide_c_str == NULL) return String("(null)");
- return String(internal::WideStringToUtf8(wide_c_str, -1).c_str());
- }
- // Similar to ShowWideCString(), except that this function encloses
- // the converted string in double quotes.
- String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
- if (wide_c_str == NULL) return String("(null)");
- return String::Format("L\"%s\"",
- String::ShowWideCString(wide_c_str).c_str());
- }
- // Compares two wide C strings. Returns true iff they have the same
- // content.
- //
- // Unlike wcscmp(), 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::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
- if (lhs == NULL) return rhs == NULL;
- if (rhs == NULL) return false;
- return wcscmp(lhs, rhs) == 0;
- }
- // Helper function for *_STREQ on wide strings.
- AssertionResult CmpHelperSTREQ(const char* expected_expression,
- const char* actual_expression,
- const wchar_t* expected,
- const wchar_t* actual) {
- if (String::WideCStringEquals(expected, actual)) {
- return AssertionSuccess();
- }
- return EqFailure(expected_expression,
- actual_expression,
- String::ShowWideCStringQuoted(expected),
- String::ShowWideCStringQuoted(actual),
- false);
- }
- // Helper function for *_STRNE on wide strings.
- AssertionResult CmpHelperSTRNE(const char* s1_expression,
- const char* s2_expression,
- const wchar_t* s1,
- const wchar_t* s2) {
- if (!String::WideCStringEquals(s1, s2)) {
- return AssertionSuccess();
- }
- Message msg;
- msg << "Expected: (" << s1_expression << ") != ("
- << s2_expression << "), actual: "
- << String::ShowWideCStringQuoted(s1)
- << " vs " << String::ShowWideCStringQuoted(s2);
- return AssertionFailure(msg);
- }
- // Compares two C strings, ignoring case. Returns true iff they have
- // the same content.
- //
- // Unlike strcasecmp(), 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::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
- if (lhs == NULL)
- return rhs == NULL;
- if (rhs == NULL)
- return false;
- return posix::StrCaseCmp(lhs, rhs) == 0;
- }
- // Compares two wide C strings, ignoring case. Returns true iff they
- // have the same content.
- //
- // Unlike wcscasecmp(), this function can handle NULL argument(s).
- // A NULL C string is considered different to any non-NULL wide C string,
- // including the empty string.
- // NB: The implementations on different platforms slightly differ.
- // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
- // environment variable. On GNU platform this method uses wcscasecmp
- // which compares according to LC_CTYPE category of the current locale.
- // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
- // current locale.
- bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
- const wchar_t* rhs) {
- if ( lhs == NULL ) return rhs == NULL;
- if ( rhs == NULL ) return false;
- #if GTEST_OS_WINDOWS
- return _wcsicmp(lhs, rhs) == 0;
- #elif GTEST_OS_LINUX
- return wcscasecmp(lhs, rhs) == 0;
- #else
- // Mac OS X and Cygwin don't define wcscasecmp. Other unknown OSes
- // may not define it either.
- wint_t left, right;
- do {
- left = towlower(*lhs++);
- right = towlower(*rhs++);
- } while (left && left == right);
- return left == right;
- #endif // OS selector
- }
- // Compares this with another String.
- // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
- // if this is greater than rhs.
- int String::Compare(const String & rhs) const {
- const char* const lhs_c_str = c_str();
- const char* const rhs_c_str = rhs.c_str();
- if (lhs_c_str == NULL) {
- return rhs_c_str == NULL ? 0 : -1; // NULL < anything except NULL
- } else if (rhs_c_str == NULL) {
- return 1;
- }
- const size_t shorter_str_len =
- length() <= rhs.length() ? length() : rhs.length();
- for (size_t i = 0; i != shorter_str_len; i++) {
- if (lhs_c_str[i] < rhs_c_str[i]) {
- return -1;
- } else if (lhs_c_str[i] > rhs_c_str[i]) {
- return 1;
- }
- }
- return (length() < rhs.length()) ? -1 :
- (length() > rhs.length()) ? 1 : 0;
- }
- // Returns true iff this String ends with the given suffix. *Any*
- // String is considered to end with a NULL or empty suffix.
- bool String::EndsWith(const char* suffix) const {
- if (suffix == NULL || CStringEquals(suffix, "")) return true;
- if (c_str() == NULL) return false;
- const size_t this_len = strlen(c_str());
- const size_t suffix_len = strlen(suffix);
- return (this_len >= suffix_len) &&
- CStringEquals(c_str() + this_len - suffix_len, suffix);
- }
- // Returns true iff this String ends with the given suffix, ignoring case.
- // Any String is considered to end with a NULL or empty suffix.
- bool String::EndsWithCaseInsensitive(const char* suffix) const {
- if (suffix == NULL || CStringEquals(suffix, "")) return true;
- if (c_str() == NULL) return false;
- const size_t this_len = strlen(c_str());
- const size_t suffix_len = strlen(suffix);
- return (this_len >= suffix_len) &&
- CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix);
- }
- // Formats a list of arguments to a String, using the same format
- // spec string as for printf.
- //
- // We do not use the StringPrintf class as it is not universally
- // available.
- //
- // The result is limited to 4096 characters (including the tailing 0).
- // If 4096 characters are not enough to format the input, or if
- // there's an error, "<formatting error or buffer exceeded>" is
- // returned.
- String String::Format(const char * format, ...) {
- va_list args;
- va_start(args, format);
- char buffer[4096];
- const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]);
- // MSVC 8 deprecates vsnprintf(), so we want to suppress warning
- // 4996 (deprecated function) there.
- #ifdef _MSC_VER // We are using MSVC.
- #pragma warning(push) // Saves the current warning state.
- #pragma warning(disable:4996) // Temporarily disables warning 4996.
- const int size = vsnprintf(buffer, kBufferSize, format, args);
- #pragma warning(pop) // Restores the warning state.
- #else // We are not using MSVC.
- const int size = vsnprintf(buffer, kBufferSize, format, args);
- #endif // _MSC_VER
- va_end(args);
- // vsnprintf()'s behavior is not portable. When the buffer is not
- // big enough, it returns a negative value in MSVC, and returns the
- // needed buffer size on Linux. When there is an output error, it
- // always returns a negative value. For simplicity, we lump the two
- // error cases together.
- if (size < 0 || size >= kBufferSize) {
- return String("<formatting error or buffer exceeded>");
- } else {
- return String(buffer, size);
- }
- }
- // Converts the buffer in a StrStream to a String, converting NUL
- // bytes to "\\0" along the way.
- String StrStreamToString(StrStream* ss) {
- const ::std::string& str = ss->str();
- const char* const start = str.c_str();
- const char* const end = start + str.length();
- // We need to use a helper StrStream to do this transformation
- // because String doesn't support push_back().
- StrStream helper;
- for (const char* ch = start; ch != end; ++ch) {
- if (*ch == '\0') {
- helper << "\\0"; // Replaces NUL with "\\0";
- } else {
- helper.put(*ch);
- }
- }
- return String(helper.str().c_str());
- }
- // Appends the user-supplied message to the Google-Test-generated message.
- String AppendUserMessage(const String& gtest_msg,
- const Message& user_msg) {
- // Appends the user message if it's non-empty.
- const String user_msg_string = user_msg.GetString();
- if (user_msg_string.empty()) {
- return gtest_msg;
- }
- Message msg;
- msg << gtest_msg << "\n" << user_msg_string;
- return msg.GetString();
- }
- } // namespace internal
- // class TestResult
- // Creates an empty TestResult.
- TestResult::TestResult()
- : death_test_count_(0),
- elapsed_time_(0) {
- }
- // D'