| // Copyright 2008, 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. |
| |
| // |
| // Google C++ Testing and Mocking Framework (Google Test) |
| // |
| // Sometimes it's desirable to build Google Test by compiling a single file. |
| // This file serves this purpose. |
| |
| // This line ensures that gtest.h can be compiled on its own, even |
| // when it's fused. |
| #include "gtest/gtest.h" |
| |
| // The following lines pull in the real gtest *.cc files. |
| // 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. |
| |
| // |
| // The Google C++ Testing and Mocking Framework (Google Test) |
| |
| // Copyright 2007, 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. |
| |
| // |
| // Utilities for testing Google Test itself and code that uses Google Test |
| // (e.g. frameworks built on top of Google Test). |
| |
| // GOOGLETEST_CM0004 DO NOT DELETE |
| |
| #ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| #define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| |
| |
| GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ |
| /* class A needs to have dll-interface to be used by clients of class B */) |
| |
| namespace testing { |
| |
| // This helper class can be used to mock out Google Test failure reporting |
| // so that we can test Google Test or code that builds on Google Test. |
| // |
| // An object of this class appends a TestPartResult object to the |
| // TestPartResultArray object given in the constructor whenever a Google Test |
| // failure is reported. It can either intercept only failures that are |
| // generated in the same thread that created this object or it can intercept |
| // all generated failures. The scope of this mock object can be controlled with |
| // the second argument to the two arguments constructor. |
| class GTEST_API_ ScopedFakeTestPartResultReporter |
| : public TestPartResultReporterInterface { |
| public: |
| // The two possible mocking modes of this object. |
| enum InterceptMode { |
| INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. |
| INTERCEPT_ALL_THREADS // Intercepts all failures. |
| }; |
| |
| // The c'tor sets this object as the test part result reporter used |
| // by Google Test. The 'result' parameter specifies where to report the |
| // results. This reporter will only catch failures generated in the current |
| // thread. DEPRECATED |
| explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); |
| |
| // Same as above, but you can choose the interception scope of this object. |
| ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, |
| TestPartResultArray* result); |
| |
| // The d'tor restores the previous test part result reporter. |
| ~ScopedFakeTestPartResultReporter() override; |
| |
| // Appends the TestPartResult object to the TestPartResultArray |
| // received in the constructor. |
| // |
| // This method is from the TestPartResultReporterInterface |
| // interface. |
| void ReportTestPartResult(const TestPartResult& result) override; |
| |
| private: |
| void Init(); |
| |
| const InterceptMode intercept_mode_; |
| TestPartResultReporterInterface* old_reporter_; |
| TestPartResultArray* const result_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); |
| }; |
| |
| namespace internal { |
| |
| // A helper class for implementing EXPECT_FATAL_FAILURE() and |
| // EXPECT_NONFATAL_FAILURE(). Its destructor 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. |
| class GTEST_API_ SingleFailureChecker { |
| public: |
| // The constructor remembers the arguments. |
| SingleFailureChecker(const TestPartResultArray* results, |
| TestPartResult::Type type, const std::string& substr); |
| ~SingleFailureChecker(); |
| private: |
| const TestPartResultArray* const results_; |
| const TestPartResult::Type type_; |
| const std::string substr_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); |
| }; |
| |
| } // namespace internal |
| |
| } // namespace testing |
| |
| GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 |
| |
| // A set of macros for testing Google Test assertions or code that's expected |
| // to generate Google Test fatal failures. It verifies that the given |
| // statement will cause exactly one fatal Google Test failure with 'substr' |
| // being part of the failure message. |
| // |
| // There are two different versions of this macro. EXPECT_FATAL_FAILURE only |
| // affects and considers failures generated in the current thread and |
| // EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. |
| // |
| // The verification of the assertion is done correctly even when the statement |
| // throws an exception or aborts the current function. |
| // |
| // Known restrictions: |
| // - 'statement' cannot reference local non-static variables or |
| // non-static members of the current object. |
| // - 'statement' cannot return a value. |
| // - You cannot stream a failure message to this macro. |
| // |
| // Note that even though the implementations of the following two |
| // macros are much alike, we cannot refactor them to use a common |
| // helper macro, due to some peculiarity in how the preprocessor |
| // works. The AcceptsMacroThatExpandsToUnprotectedComma test in |
| // gtest_unittest.cc will fail to compile if we do that. |
| #define EXPECT_FATAL_FAILURE(statement, substr) \ |
| do { \ |
| class GTestExpectFatalFailureHelper {\ |
| public:\ |
| static void Execute() { statement; }\ |
| };\ |
| ::testing::TestPartResultArray gtest_failures;\ |
| ::testing::internal::SingleFailureChecker gtest_checker(\ |
| >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ |
| {\ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ |
| ::testing::ScopedFakeTestPartResultReporter:: \ |
| INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ |
| GTestExpectFatalFailureHelper::Execute();\ |
| }\ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| #define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
| do { \ |
| class GTestExpectFatalFailureHelper {\ |
| public:\ |
| static void Execute() { statement; }\ |
| };\ |
| ::testing::TestPartResultArray gtest_failures;\ |
| ::testing::internal::SingleFailureChecker gtest_checker(\ |
| >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ |
| {\ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ |
| ::testing::ScopedFakeTestPartResultReporter:: \ |
| INTERCEPT_ALL_THREADS, >est_failures);\ |
| GTestExpectFatalFailureHelper::Execute();\ |
| }\ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| // A macro for testing Google Test assertions or code that's expected to |
| // generate Google Test non-fatal failures. It asserts that the given |
| // statement will cause exactly one non-fatal Google Test failure with 'substr' |
| // being part of the failure message. |
| // |
| // There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only |
| // affects and considers failures generated in the current thread and |
| // EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. |
| // |
| // 'statement' is allowed to reference local variables and members of |
| // the current object. |
| // |
| // The verification of the assertion is done correctly even when the statement |
| // throws an exception or aborts the current function. |
| // |
| // Known restrictions: |
| // - You cannot stream a failure message to this macro. |
| // |
| // Note that even though the implementations of the following two |
| // macros are much alike, we cannot refactor them to use a common |
| // helper macro, due to some peculiarity in how the preprocessor |
| // works. If we do that, the code won't compile when the user gives |
| // EXPECT_NONFATAL_FAILURE() a statement that contains a macro that |
| // expands to code containing an unprotected comma. The |
| // AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc |
| // catches that. |
| // |
| // For the same reason, we have to write |
| // if (::testing::internal::AlwaysTrue()) { statement; } |
| // instead of |
| // GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) |
| // to avoid an MSVC warning on unreachable code. |
| #define EXPECT_NONFATAL_FAILURE(statement, substr) \ |
| do {\ |
| ::testing::TestPartResultArray gtest_failures;\ |
| ::testing::internal::SingleFailureChecker gtest_checker(\ |
| >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ |
| (substr));\ |
| {\ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ |
| ::testing::ScopedFakeTestPartResultReporter:: \ |
| INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ |
| if (::testing::internal::AlwaysTrue()) { statement; }\ |
| }\ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| #define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
| do {\ |
| ::testing::TestPartResultArray gtest_failures;\ |
| ::testing::internal::SingleFailureChecker gtest_checker(\ |
| >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ |
| (substr));\ |
| {\ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ |
| ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ |
| >est_failures);\ |
| if (::testing::internal::AlwaysTrue()) { statement; }\ |
| }\ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| #endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| |
| #include <ctype.h> |
| #include <math.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <time.h> |
| #include <wchar.h> |
| #include <wctype.h> |
| |
| #include <algorithm> |
| #include <iomanip> |
| #include <limits> |
| #include <list> |
| #include <map> |
| #include <ostream> // NOLINT |
| #include <sstream> |
| #include <vector> |
| |
| #if GTEST_OS_LINUX |
| |
| # define GTEST_HAS_GETTIMEOFDAY_ 1 |
| |
| # include <fcntl.h> // NOLINT |
| # include <limits.h> // NOLINT |
| # include <sched.h> // NOLINT |
| // Declares vsnprintf(). This header is not available on Windows. |
| # include <strings.h> // NOLINT |
| # include <sys/mman.h> // NOLINT |
| # include <sys/time.h> // NOLINT |
| # include <unistd.h> // NOLINT |
| # include <string> |
| |
| #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 |
| # undef min |
| |
| #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(). |
| # 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 |
| # undef min |
| |
| #else |
| |
| // Assume other platforms have 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 |
| |
| #if GTEST_CAN_STREAM_RESULTS_ |
| # include <arpa/inet.h> // NOLINT |
| # include <netdb.h> // NOLINT |
| # include <sys/socket.h> // NOLINT |
| # include <sys/types.h> // NOLINT |
| #endif |
| |
| // 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. |
| |
| // Utility functions and classes used by the Google C++ testing framework.// |
| // This file contains purely Google Test's internal implementation. Please |
| // DO NOT #INCLUDE IT IN A USER PROGRAM. |
| |
| #ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ |
| #define GTEST_SRC_GTEST_INTERNAL_INL_H_ |
| |
| #ifndef _WIN32_WCE |
| # include <errno.h> |
| #endif // !_WIN32_WCE |
| #include <stddef.h> |
| #include <stdlib.h> // For strtoll/_strtoul64/malloc/free. |
| #include <string.h> // For memmove. |
| |
| #include <algorithm> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| |
| #if GTEST_CAN_STREAM_RESULTS_ |
| # include <arpa/inet.h> // NOLINT |
| # include <netdb.h> // NOLINT |
| #endif |
| |
| #if GTEST_OS_WINDOWS |
| # include <windows.h> // NOLINT |
| #endif // GTEST_OS_WINDOWS |
| |
| |
| GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ |
| /* class A needs to have dll-interface to be used by clients of class B */) |
| |
| namespace testing { |
| |
| // Declares the flags. |
| // |
| // We don't want the users to modify this flag in the code, but want |
| // Google Test's own unit tests to be able to access it. Therefore we |
| // declare it here as opposed to in gtest.h. |
| GTEST_DECLARE_bool_(death_test_use_fork); |
| |
| namespace internal { |
| |
| // The value of GetTestTypeId() as seen from within the Google Test |
| // library. This is solely for testing GetTestTypeId(). |
| GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; |
| |
| // Names of the flags (needed for parsing Google Test flags). |
| const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; |
| const char kBreakOnFailureFlag[] = "break_on_failure"; |
| const char kCatchExceptionsFlag[] = "catch_exceptions"; |
| const char kColorFlag[] = "color"; |
| const char kFilterFlag[] = "filter"; |
| const char kListTestsFlag[] = "list_tests"; |
| const char kOutputFlag[] = "output"; |
| const char kPrintTimeFlag[] = "print_time"; |
| const char kPrintUTF8Flag[] = "print_utf8"; |
| const char kRandomSeedFlag[] = "random_seed"; |
| const char kRepeatFlag[] = "repeat"; |
| const char kShuffleFlag[] = "shuffle"; |
| const char kStackTraceDepthFlag[] = "stack_trace_depth"; |
| const char kStreamResultToFlag[] = "stream_result_to"; |
| const char kThrowOnFailureFlag[] = "throw_on_failure"; |
| const char kFlagfileFlag[] = "flagfile"; |
| |
| // A valid random seed must be in [1, kMaxRandomSeed]. |
| const int kMaxRandomSeed = 99999; |
| |
| // g_help_flag is true iff the --help flag or an equivalent form is |
| // specified on the command line. |
| GTEST_API_ extern bool g_help_flag; |
| |
| // Returns the current time in milliseconds. |
| GTEST_API_ TimeInMillis GetTimeInMillis(); |
| |
| // Returns true iff Google Test should use colors in the output. |
| GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); |
| |
| // Formats the given time in milliseconds as seconds. |
| GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); |
| |
| // Converts the given time in milliseconds to a date string in the ISO 8601 |
| // format, without the timezone information. N.B.: due to the use the |
| // non-reentrant localtime() function, this function is not thread safe. Do |
| // not use it in any code that can be called from multiple threads. |
| GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms); |
| |
| // Parses a string for an Int32 flag, in the form of "--flag=value". |
| // |
| // On success, stores the value of the flag in *value, and returns |
| // true. On failure, returns false without changing *value. |
| GTEST_API_ bool ParseInt32Flag( |
| const char* str, const char* flag, Int32* value); |
| |
| // Returns a random seed in range [1, kMaxRandomSeed] based on the |
| // given --gtest_random_seed flag value. |
| inline int GetRandomSeedFromFlag(Int32 random_seed_flag) { |
| const unsigned int raw_seed = (random_seed_flag == 0) ? |
| static_cast<unsigned int>(GetTimeInMillis()) : |
| static_cast<unsigned int>(random_seed_flag); |
| |
| // Normalizes the actual seed to range [1, kMaxRandomSeed] such that |
| // it's easy to type. |
| const int normalized_seed = |
| static_cast<int>((raw_seed - 1U) % |
| static_cast<unsigned int>(kMaxRandomSeed)) + 1; |
| return normalized_seed; |
| } |
| |
| // Returns the first valid random seed after 'seed'. The behavior is |
| // undefined if 'seed' is invalid. The seed after kMaxRandomSeed is |
| // considered to be 1. |
| inline int GetNextRandomSeed(int seed) { |
| GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) |
| << "Invalid random seed " << seed << " - must be in [1, " |
| << kMaxRandomSeed << "]."; |
| const int next_seed = seed + 1; |
| return (next_seed > kMaxRandomSeed) ? 1 : next_seed; |
| } |
| |
| // This class saves the values of all Google Test flags in its c'tor, and |
| // restores them in its d'tor. |
| class GTestFlagSaver { |
| public: |
| // The c'tor. |
| GTestFlagSaver() { |
| also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); |
| break_on_failure_ = GTEST_FLAG(break_on_failure); |
| catch_exceptions_ = GTEST_FLAG(catch_exceptions); |
| color_ = GTEST_FLAG(color); |
| death_test_style_ = GTEST_FLAG(death_test_style); |
| death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); |
| filter_ = GTEST_FLAG(filter); |
| internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); |
| list_tests_ = GTEST_FLAG(list_tests); |
| output_ = GTEST_FLAG(output); |
| print_time_ = GTEST_FLAG(print_time); |
| print_utf8_ = GTEST_FLAG(print_utf8); |
| random_seed_ = GTEST_FLAG(random_seed); |
| repeat_ = GTEST_FLAG(repeat); |
| shuffle_ = GTEST_FLAG(shuffle); |
| stack_trace_depth_ = GTEST_FLAG(stack_trace_depth); |
| stream_result_to_ = GTEST_FLAG(stream_result_to); |
| throw_on_failure_ = GTEST_FLAG(throw_on_failure); |
| } |
| |
| // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. |
| ~GTestFlagSaver() { |
| GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; |
| GTEST_FLAG(break_on_failure) = break_on_failure_; |
| GTEST_FLAG(catch_exceptions) = catch_exceptions_; |
| GTEST_FLAG(color) = color_; |
| GTEST_FLAG(death_test_style) = death_test_style_; |
| GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; |
| GTEST_FLAG(filter) = filter_; |
| GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; |
| GTEST_FLAG(list_tests) = list_tests_; |
| GTEST_FLAG(output) = output_; |
| GTEST_FLAG(print_time) = print_time_; |
| GTEST_FLAG(print_utf8) = print_utf8_; |
| GTEST_FLAG(random_seed) = random_seed_; |
| GTEST_FLAG(repeat) = repeat_; |
| GTEST_FLAG(shuffle) = shuffle_; |
| GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; |
| GTEST_FLAG(stream_result_to) = stream_result_to_; |
| GTEST_FLAG(throw_on_failure) = throw_on_failure_; |
| } |
| |
| private: |
| // Fields for saving the original values of flags. |
| bool also_run_disabled_tests_; |
| bool break_on_failure_; |
| bool catch_exceptions_; |
| std::string color_; |
| std::string death_test_style_; |
| bool death_test_use_fork_; |
| std::string filter_; |
| std::string internal_run_death_test_; |
| bool list_tests_; |
| std::string output_; |
| bool print_time_; |
| bool print_utf8_; |
| internal::Int32 random_seed_; |
| internal::Int32 repeat_; |
| bool shuffle_; |
| internal::Int32 stack_trace_depth_; |
| std::string stream_result_to_; |
| bool throw_on_failure_; |
| } GTEST_ATTRIBUTE_UNUSED_; |
| |
| // 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. |
| // 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 converted |
| // to "(Invalid Unicode 0xXXXXXXXX)". |
| GTEST_API_ std::string CodePointToUtf8(UInt32 code_point); |
| |
| // 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) |
| // 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. |
| GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars); |
| |
| // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file |
| // if the variable is present. If a file already exists at this location, this |
| // function will write over it. If the variable is present, but the file cannot |
| // be created, prints an error and exits. |
| void WriteToShardStatusFileIfNeeded(); |
| |
| // Checks whether sharding is enabled by examining the relevant |
| // environment variable values. If the variables are present, |
| // but inconsistent (e.g., shard_index >= total_shards), prints |
| // an error and exits. If in_subprocess_for_death_test, sharding is |
| // disabled because it must only be applied to the original test |
| // process. Otherwise, we could filter out death tests we intended to execute. |
| GTEST_API_ bool ShouldShard(const char* total_shards_str, |
| const char* shard_index_str, |
| bool in_subprocess_for_death_test); |
| |
| // Parses the environment variable var as an Int32. If it is unset, |
| // returns default_val. If it is not an Int32, prints an error and |
| // and aborts. |
| GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); |
| |
| // Given the total number of shards, the shard index, and the test id, |
| // returns true iff the test should be run on this shard. The test id is |
| // some arbitrary but unique non-negative integer assigned to each test |
| // method. Assumes that 0 <= shard_index < total_shards. |
| GTEST_API_ bool ShouldRunTestOnShard( |
| int total_shards, int shard_index, int test_id); |
| |
| // STL container utilities. |
| |
| // Returns the number of elements in the given container that satisfy |
| // the given predicate. |
| template <class Container, typename Predicate> |
| inline int CountIf(const Container& c, Predicate predicate) { |
| // Implemented as an explicit loop since std::count_if() in libCstd on |
| // Solaris has a non-standard signature. |
| int count = 0; |
| for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) { |
| if (predicate(*it)) |
| ++count; |
| } |
| return count; |
| } |
| |
| // Applies a function/functor to each element in the container. |
| template <class Container, typename Functor> |
| void ForEach(const Container& c, Functor functor) { |
| std::for_each(c.begin(), c.end(), functor); |
| } |
| |
| // Returns the i-th element of the vector, or default_value if i is not |
| // in range [0, v.size()). |
| template <typename E> |
| inline E GetElementOr(const std::vector<E>& v, int i, E default_value) { |
| return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i]; |
| } |
| |
| // Performs an in-place shuffle of a range of the vector's elements. |
| // 'begin' and 'end' are element indices as an STL-style range; |
| // i.e. [begin, end) are shuffled, where 'end' == size() means to |
| // shuffle to the end of the vector. |
| template <typename E> |
| void ShuffleRange(internal::Random* random, int begin, int end, |
| std::vector<E>* v) { |
| const int size = static_cast<int>(v->size()); |
| GTEST_CHECK_(0 <= begin && begin <= size) |
| << "Invalid shuffle range start " << begin << ": must be in range [0, " |
| << size << "]."; |
| GTEST_CHECK_(begin <= end && end <= size) |
| << "Invalid shuffle range finish " << end << ": must be in range [" |
| << begin << ", " << size << "]."; |
| |
| // Fisher-Yates shuffle, from |
| // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle |
| for (int range_width = end - begin; range_width >= 2; range_width--) { |
| const int last_in_range = begin + range_width - 1; |
| const int selected = begin + random->Generate(range_width); |
| std::swap((*v)[selected], (*v)[last_in_range]); |
| } |
| } |
| |
| // Performs an in-place shuffle of the vector's elements. |
| template <typename E> |
| inline void Shuffle(internal::Random* random, std::vector<E>* v) { |
| ShuffleRange(random, 0, static_cast<int>(v->size()), v); |
| } |
| |
| // A function for deleting an object. Handy for being used as a |
| // functor. |
| template <typename T> |
| static void Delete(T* x) { |
| delete x; |
| } |
| |
| // A predicate that checks the key of a TestProperty against a known key. |
| // |
| // TestPropertyKeyIs is copyable. |
| class TestPropertyKeyIs { |
| public: |
| // Constructor. |
| // |
| // TestPropertyKeyIs has NO default constructor. |
| explicit TestPropertyKeyIs(const std::string& key) : key_(key) {} |
| |
| // Returns true iff the test name of test property matches on key_. |
| bool operator()(const TestProperty& test_property) const { |
| return test_property.key() == key_; |
| } |
| |
| private: |
| std::string key_; |
| }; |
| |
| // Class UnitTestOptions. |
| // |
| // This class contains functions for processing options the user |
| // specifies when running the tests. It has only static members. |
| // |
| // In most cases, the user can specify an option using either an |
| // environment variable or a command line flag. E.g. you can set the |
| // test filter using either GTEST_FILTER or --gtest_filter. If both |
| // the variable and the flag are present, the latter overrides the |
| // former. |
| class GTEST_API_ UnitTestOptions { |
| public: |
| // Functions for processing the gtest_output flag. |
| |
| // Returns the output format, or "" for normal printed output. |
| static std::string GetOutputFormat(); |
| |
| // Returns the absolute path of the requested output file, or the |
| // default (test_detail.xml in the original working directory) if |
| // none was explicitly specified. |
| static std::string GetAbsolutePathToOutputFile(); |
| |
| // Functions for processing the gtest_filter flag. |
| |
| // Returns true iff the wildcard pattern matches the string. The |
| // first ':' or '\0' character in pattern marks the end of it. |
| // |
| // This recursive algorithm isn't very efficient, but is clear and |
| // works well enough for matching test names, which are short. |
| static bool PatternMatchesString(const char *pattern, const char *str); |
| |
| // Returns true iff the user-specified filter matches the test suite |
| // name and the test name. |
| static bool FilterMatchesTest(const std::string& test_suite_name, |
| const std::string& test_name); |
| |
| #if GTEST_OS_WINDOWS |
| // Function for supporting the gtest_catch_exception flag. |
| |
| // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the |
| // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. |
| // This function is useful as an __except condition. |
| static int GTestShouldProcessSEH(DWORD exception_code); |
| #endif // GTEST_OS_WINDOWS |
| |
| // Returns true if "name" matches the ':' separated list of glob-style |
| // filters in "filter". |
| static bool MatchesFilter(const std::string& name, const char* filter); |
| }; |
| |
| // Returns the current application's name, removing directory path if that |
| // is present. Used by UnitTestOptions::GetOutputFile. |
| GTEST_API_ FilePath GetCurrentExecutableName(); |
| |
| // The role interface for getting the OS stack trace as a string. |
| class OsStackTraceGetterInterface { |
| public: |
| OsStackTraceGetterInterface() {} |
| virtual ~OsStackTraceGetterInterface() {} |
| |
| // Returns the current OS stack trace as an std::string. Parameters: |
| // |
| // max_depth - the maximum number of stack frames to be included |
| // in the trace. |
| // skip_count - the number of top frames to be skipped; doesn't count |
| // against max_depth. |
| virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0; |
| |
| // UponLeavingGTest() should be called immediately before Google Test calls |
| // user code. It saves some information about the current stack that |
| // CurrentStackTrace() will use to find and hide Google Test stack frames. |
| virtual void UponLeavingGTest() = 0; |
| |
| // This string is inserted in place of stack frames that are part of |
| // Google Test's implementation. |
| static const char* const kElidedFramesMarker; |
| |
| private: |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); |
| }; |
| |
| // A working implementation of the OsStackTraceGetterInterface interface. |
| class OsStackTraceGetter : public OsStackTraceGetterInterface { |
| public: |
| OsStackTraceGetter() {} |
| |
| std::string CurrentStackTrace(int max_depth, int skip_count) override; |
| void UponLeavingGTest() override; |
| |
| private: |
| #if GTEST_HAS_ABSL |
| Mutex mutex_; // Protects all internal state. |
| |
| // We save the stack frame below the frame that calls user code. |
| // We do this because the address of the frame immediately below |
| // the user code changes between the call to UponLeavingGTest() |
| // and any calls to the stack trace code from within the user code. |
| void* caller_frame_ = nullptr; |
| #endif // GTEST_HAS_ABSL |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); |
| }; |
| |
| // Information about a Google Test trace point. |
| struct TraceInfo { |
| const char* file; |
| int line; |
| std::string message; |
| }; |
| |
| // This is the default global test part result reporter used in UnitTestImpl. |
| // This class should only be used by UnitTestImpl. |
| class DefaultGlobalTestPartResultReporter |
| : public TestPartResultReporterInterface { |
| public: |
| explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); |
| // Implements the TestPartResultReporterInterface. Reports the test part |
| // result in the current test. |
| void ReportTestPartResult(const TestPartResult& result) override; |
| |
| private: |
| UnitTestImpl* const unit_test_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); |
| }; |
| |
| // This is the default per thread test part result reporter used in |
| // UnitTestImpl. This class should only be used by UnitTestImpl. |
| class DefaultPerThreadTestPartResultReporter |
| : public TestPartResultReporterInterface { |
| public: |
| explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); |
| // Implements the TestPartResultReporterInterface. The implementation just |
| // delegates to the current global test part result reporter of *unit_test_. |
| void ReportTestPartResult(const TestPartResult& result) override; |
| |
| private: |
| UnitTestImpl* const unit_test_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); |
| }; |
| |
| // The private implementation of the UnitTest class. We don't protect |
| // the methods under a mutex, as this class is not accessible by a |
| // user and the UnitTest class that delegates work to this class does |
| // proper locking. |
| class GTEST_API_ UnitTestImpl { |
| public: |
| explicit UnitTestImpl(UnitTest* parent); |
| virtual ~UnitTestImpl(); |
| |
| // There are two different ways to register your own TestPartResultReporter. |
| // You can register your own repoter to listen either only for test results |
| // from the current thread or for results from all threads. |
| // By default, each per-thread test result repoter just passes a new |
| // TestPartResult to the global test result reporter, which registers the |
| // test part result for the currently running test. |
| |
| // Returns the global test part result reporter. |
| TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); |
| |
| // Sets the global test part result reporter. |
| void SetGlobalTestPartResultReporter( |
| TestPartResultReporterInterface* reporter); |
| |
| // Returns the test part result reporter for the current thread. |
| TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); |
| |
| // Sets the test part result reporter for the current thread. |
| void SetTestPartResultReporterForCurrentThread( |
| TestPartResultReporterInterface* reporter); |
| |
| // Gets the number of successful test suites. |
| int successful_test_suite_count() const; |
| |
| // Gets the number of failed test suites. |
| int failed_test_suite_count() const; |
| |
| // Gets the number of all test suites. |
| int total_test_suite_count() const; |
| |
| // Gets the number of all test suites that contain at least one test |
| // that should run. |
| int test_suite_to_run_count() const; |
| |
| // Gets the number of successful tests. |
| int successful_test_count() const; |
| |
| // Gets the number of skipped tests. |
| int skipped_test_count() const; |
| |
| // Gets the number of failed tests. |
| int failed_test_count() const; |
| |
| // Gets the number of disabled tests that will be reported in the XML report. |
| int reportable_disabled_test_count() const; |
| |
| // Gets the number of disabled tests. |
| int disabled_test_count() const; |
| |
| // Gets the number of tests to be printed in the XML report. |
| int reportable_test_count() const; |
| |
| // Gets the number of all tests. |
| int total_test_count() const; |
| |
| // Gets the number of tests that should run. |
| int test_to_run_count() const; |
| |
| // Gets the time of the test program start, in ms from the start of the |
| // UNIX epoch. |
| TimeInMillis start_timestamp() const { return start_timestamp_; } |
| |
| // Gets the elapsed time, in milliseconds. |
| TimeInMillis elapsed_time() const { return elapsed_time_; } |
| |
| // Returns true iff the unit test passed (i.e. all test suites passed). |
| bool Passed() const { return !Failed(); } |
| |
| // Returns true iff the unit test failed (i.e. some test suite failed |
| // or something outside of all tests failed). |
| bool Failed() const { |
| return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed(); |
| } |
| |
| // Gets the i-th test suite among all the test suites. i can range from 0 to |
| // total_test_suite_count() - 1. If i is not in that range, returns NULL. |
| const TestSuite* GetTestSuite(int i) const { |
| const int index = GetElementOr(test_suite_indices_, i, -1); |
| return index < 0 ? nullptr : test_suites_[i]; |
| } |
| |
| // Legacy API is deprecated but still available |
| #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ |
| const TestCase* GetTestCase(int i) const { return GetTestSuite(i); } |
| #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ |
| |
| // Gets the i-th test suite among all the test suites. i can range from 0 to |
| // total_test_suite_count() - 1. If i is not in that range, returns NULL. |
| TestSuite* GetMutableSuiteCase(int i) { |
| const int index = GetElementOr(test_suite_indices_, i, -1); |
| return index < 0 ? nullptr : test_suites_[index]; |
| } |
| |
| // Provides access to the event listener list. |
| TestEventListeners* listeners() { return &listeners_; } |
| |
| // Returns the TestResult for the test that's currently running, or |
| // the TestResult for the ad hoc test if no test is running. |
| TestResult* current_test_result(); |
| |
| // Returns the TestResult for the ad hoc test. |
| const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } |
| |
| // Sets the OS stack trace getter. |
| // |
| // Does nothing if the input and the current OS stack trace getter |
| // are the same; otherwise, deletes the old getter and makes the |
| // input the current getter. |
| void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); |
| |
| // Returns the current OS stack trace getter if it is not NULL; |
| // otherwise, creates an OsStackTraceGetter, makes it the current |
| // getter, and returns it. |
| OsStackTraceGetterInterface* os_stack_trace_getter(); |
| |
| // Returns the current OS stack trace as 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 CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_; |
| |
| // Finds and returns a TestSuite with the given name. If one doesn't |
| // exist, creates one and returns it. |
| // |
| // Arguments: |
| // |
| // test_suite_name: name of the test suite |
| // type_param: the name of the test's type parameter, or NULL if |
| // this is not a typed or a type-parameterized test. |
| // set_up_tc: pointer to the function that sets up the test suite |
| // tear_down_tc: pointer to the function that tears down the test suite |
| TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param, |
| internal::SetUpTestSuiteFunc set_up_tc, |
| internal::TearDownTestSuiteFunc tear_down_tc); |
| |
| // Legacy API is deprecated but still available |
| #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ |
| TestCase* GetTestCase(const char* test_case_name, const char* type_param, |
| internal::SetUpTestSuiteFunc set_up_tc, |
| internal::TearDownTestSuiteFunc tear_down_tc) { |
| return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc); |
| } |
| #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ |
| |
| // Adds a TestInfo to the unit test. |
| // |
| // Arguments: |
| // |
| // set_up_tc: pointer to the function that sets up the test suite |
| // tear_down_tc: pointer to the function that tears down the test suite |
| // test_info: the TestInfo object |
| void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, |
| internal::TearDownTestSuiteFunc tear_down_tc, |
| TestInfo* test_info) { |
| // In order to support thread-safe death tests, we need to |
| // remember the original working directory when the test program |
| // was first invoked. We cannot do this in RUN_ALL_TESTS(), as |
| // the user may have changed the current directory before calling |
| // RUN_ALL_TESTS(). Therefore we capture the current directory in |
| // AddTestInfo(), which is called to register a TEST or TEST_F |
| // before main() is reached. |
| if (original_working_dir_.IsEmpty()) { |
| original_working_dir_.Set(FilePath::GetCurrentDir()); |
| GTEST_CHECK_(!original_working_dir_.IsEmpty()) |
| << "Failed to get the current working directory."; |
| } |
| |
| GetTestSuite(test_info->test_suite_name(), test_info->type_param(), |
| set_up_tc, tear_down_tc) |
| ->AddTestInfo(test_info); |
| } |
| |
| // Returns ParameterizedTestSuiteRegistry object used to keep track of |
| // value-parameterized tests and instantiate and register them. |
| internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() { |
| return parameterized_test_registry_; |
| } |
| |
| // Sets the TestSuite object for the test that's currently running. |
| void set_current_test_suite(TestSuite* a_current_test_suite) { |
| current_test_suite_ = a_current_test_suite; |
| } |
| |
| // Sets the TestInfo object for the test that's currently running. If |
| // current_test_info is NULL, the assertion results will be stored in |
| // ad_hoc_test_result_. |
| void set_current_test_info(TestInfo* a_current_test_info) { |
| current_test_info_ = a_current_test_info; |
| } |
| |
| // Registers all parameterized tests defined using TEST_P and |
| // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter |
| // combination. This method can be called more then once; it has guards |
| // protecting from registering the tests more then once. If |
| // value-parameterized tests are disabled, RegisterParameterizedTests is |
| // present but does nothing. |
| void RegisterParameterizedTests(); |
| |
| // Runs all tests in this UnitTest object, prints the result, and |
| // returns true if all tests are successful. If any exception is |
| // thrown during a test, this test is considered to be failed, but |
| // the rest of the tests will still be run. |
| bool RunAllTests(); |
| |
| // Clears the results of all tests, except the ad hoc tests. |
| void ClearNonAdHocTestResult() { |
| ForEach(test_suites_, TestSuite::ClearTestSuiteResult); |
| } |
| |
| // Clears the results of ad-hoc test assertions. |
| void ClearAdHocTestResult() { |
| ad_hoc_test_result_.Clear(); |
| } |
| |
| // Adds a TestProperty to the current TestResult object when invoked in a |
| // context of a test or a test suite, or to the global property set. If the |
| // result already contains a property with the same key, the value will be |
| // updated. |
| void RecordProperty(const TestProperty& test_property); |
| |
| enum ReactionToSharding { |
| HONOR_SHARDING_PROTOCOL, |
| IGNORE_SHARDING_PROTOCOL |
| }; |
| |
| // Matches the full name of each test against the user-specified |
| // filter to decide whether the test should run, then records the |
| // result in each TestSuite and TestInfo object. |
| // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests |
| // based on sharding variables in the environment. |
| // Returns the number of tests that should run. |
| int FilterTests(ReactionToSharding shard_tests); |
| |
| // Prints the names of the tests matching the user-specified filter flag. |
| void ListTestsMatchingFilter(); |
| |
| const TestSuite* current_test_suite() const { return current_test_suite_; } |
| TestInfo* current_test_info() { return current_test_info_; } |
| const TestInfo* current_test_info() const { return current_test_info_; } |
| |
| // Returns the vector of environments that need to be set-up/torn-down |
| // before/after the tests are run. |
| std::vector<Environment*>& environments() { return environments_; } |
| |
| // Getters for the per-thread Google Test trace stack. |
| std::vector<TraceInfo>& gtest_trace_stack() { |
| return *(gtest_trace_stack_.pointer()); |
| } |
| const std::vector<TraceInfo>& gtest_trace_stack() const { |
| return gtest_trace_stack_.get(); |
| } |
| |
| #if GTEST_HAS_DEATH_TEST |
| void InitDeathTestSubprocessControlInfo() { |
| internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); |
| } |
| // Returns a pointer to the parsed --gtest_internal_run_death_test |
| // flag, or NULL if that flag was not specified. |
| // This information is useful only in a death test child process. |
| // Must not be called before a call to InitGoogleTest. |
| const InternalRunDeathTestFlag* internal_run_death_test_flag() const { |
| return internal_run_death_test_flag_.get(); |
| } |
| |
| // Returns a pointer to the current death test factory. |
| internal::DeathTestFactory* death_test_factory() { |
| return death_test_factory_.get(); |
| } |
| |
| void SuppressTestEventsIfInSubprocess(); |
| |
| friend class ReplaceDeathTestFactory; |
| #endif // GTEST_HAS_DEATH_TEST |
| |
| // Initializes the event listener performing XML output as specified by |
| // UnitTestOptions. Must not be called before InitGoogleTest. |
| void ConfigureXmlOutput(); |
| |
| #if GTEST_CAN_STREAM_RESULTS_ |
| // Initializes the event listener for streaming test results to a socket. |
| // Must not be called before InitGoogleTest. |
| void ConfigureStreamingOutput(); |
| #endif |
| |
| // Performs initialization dependent upon flag values obtained in |
| // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to |
| // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest |
| // this function is also called from RunAllTests. Since this function can be |
| // called more than once, it has to be idempotent. |
| void PostFlagParsingInit(); |
| |
| // Gets the random seed used at the start of the current test iteration. |
| int random_seed() const { return random_seed_; } |
| |
| // Gets the random number generator. |
| internal::Random* random() { return &random_; } |
| |
| // Shuffles all test suites, and the tests within each test suite, |
| // making sure that death tests are still run first. |
| void ShuffleTests(); |
| |
| // Restores the test suites and tests to their order before the first shuffle. |
| void UnshuffleTests(); |
| |
| // Returns the value of GTEST_FLAG(catch_exceptions) at the moment |
| // UnitTest::Run() starts. |
| bool catch_exceptions() const { return catch_exceptions_; } |
| |
| private: |
| friend class ::testing::UnitTest; |
| |
| // Used by UnitTest::Run() to capture the state of |
| // GTEST_FLAG(catch_exceptions) at the moment it starts. |
| void set_catch_exceptions(bool value) { catch_exceptions_ = value; } |
| |
| // The UnitTest object that owns this implementation object. |
| UnitTest* const parent_; |
| |
| // The working directory when the first TEST() or TEST_F() was |
| // executed. |
| internal::FilePath original_working_dir_; |
| |
| // The default test part result reporters. |
| DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; |
| DefaultPerThreadTestPartResultReporter |
| default_per_thread_test_part_result_reporter_; |
| |
| // Points to (but doesn't own) the global test part result reporter. |
| TestPartResultReporterInterface* global_test_part_result_repoter_; |
| |
| // Protects read and write access to global_test_part_result_reporter_. |
| internal::Mutex global_test_part_result_reporter_mutex_; |
| |
| // Points to (but doesn't own) the per-thread test part result reporter. |
| internal::ThreadLocal<TestPartResultReporterInterface*> |
| per_thread_test_part_result_reporter_; |
| |
| // The vector of environments that need to be set-up/torn-down |
| // before/after the tests are run. |
| std::vector<Environment*> environments_; |
| |
| // The vector of TestSuites in their original order. It owns the |
| // elements in the vector. |
| std::vector<TestSuite*> test_suites_; |
| |
| // Provides a level of indirection for the test suite list to allow |
| // easy shuffling and restoring the test suite order. The i-th |
| // element of this vector is the index of the i-th test suite in the |
| // shuffled order. |
| std::vector<int> test_suite_indices_; |
| |
| // ParameterizedTestRegistry object used to register value-parameterized |
| // tests. |
| internal::ParameterizedTestSuiteRegistry parameterized_test_registry_; |
| |
| // Indicates whether RegisterParameterizedTests() has been called already. |
| bool parameterized_tests_registered_; |
| |
| // Index of the last death test suite registered. Initially -1. |
| int last_death_test_suite_; |
| |
| // This points to the TestSuite for the currently running test. It |
| // changes as Google Test goes through one test suite after another. |
| // When no test is running, this is set to NULL and Google Test |
| // stores assertion results in ad_hoc_test_result_. Initially NULL. |
| TestSuite* current_test_suite_; |
| |
| // This points to the TestInfo for the currently running test. It |
| // changes as Google Test goes through one test after another. When |
| // no test is running, this is set to NULL and Google Test stores |
| // assertion results in ad_hoc_test_result_. Initially NULL. |
| TestInfo* current_test_info_; |
| |
| // Normally, a user only writes assertions inside a TEST or TEST_F, |
| // or inside a function called by a TEST or TEST_F. Since Google |
| // Test keeps track of which test is current running, it can |
| // associate such an assertion with the test it belongs to. |
| // |
| // If an assertion is encountered when no TEST or TEST_F is running, |
| // Google Test attributes the assertion result to an imaginary "ad hoc" |
| // test, and records the result in ad_hoc_test_result_. |
| TestResult ad_hoc_test_result_; |
| |
| // The list of event listeners that can be used to track events inside |
| // Google Test. |
| TestEventListeners listeners_; |
| |
| // The OS stack trace getter. Will be deleted when the UnitTest |
| // object is destructed. By default, an OsStackTraceGetter is used, |
| // but the user can set this field to use a custom getter if that is |
| // desired. |
| OsStackTraceGetterInterface* os_stack_trace_getter_; |
| |
| // True iff PostFlagParsingInit() has been called. |
| bool post_flag_parse_init_performed_; |
| |
| // The random number seed used at the beginning of the test run. |
| int random_seed_; |
| |
| // Our random number generator. |
| internal::Random random_; |
| |
| // The time of the test program start, in ms from the start of the |
| // UNIX epoch. |
| TimeInMillis start_timestamp_; |
| |
| // How long the test took to run, in milliseconds. |
| TimeInMillis elapsed_time_; |
| |
| #if GTEST_HAS_DEATH_TEST |
| // The decomposed components of the gtest_internal_run_death_test flag, |
| // parsed when RUN_ALL_TESTS is called. |
| std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; |
| std::unique_ptr<internal::DeathTestFactory> death_test_factory_; |
| #endif // GTEST_HAS_DEATH_TEST |
| |
| // A per-thread stack of traces created by the SCOPED_TRACE() macro. |
| internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_; |
| |
| // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() |
| // starts. |
| bool catch_exceptions_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); |
| }; // class UnitTestImpl |
| |
| // Convenience function for accessing the global UnitTest |
| // implementation object. |
| inline UnitTestImpl* GetUnitTestImpl() { |
| return UnitTest::GetInstance()->impl(); |
| } |
| |
| #if GTEST_USES_SIMPLE_RE |
| |
| // Internal helper functions for implementing the simple regular |
| // expression matcher. |
| GTEST_API_ bool IsInSet(char ch, const char* str); |
| GTEST_API_ bool IsAsciiDigit(char ch); |
| GTEST_API_ bool IsAsciiPunct(char ch); |
| GTEST_API_ bool IsRepeat(char ch); |
| GTEST_API_ bool IsAsciiWhiteSpace(char ch); |
| GTEST_API_ bool IsAsciiWordChar(char ch); |
| GTEST_API_ bool IsValidEscape(char ch); |
| GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); |
| GTEST_API_ bool ValidateRegex(const char* regex); |
| GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); |
| GTEST_API_ bool MatchRepetitionAndRegexAtHead( |
| bool escaped, char ch, char repeat, const char* regex, const char* str); |
| GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); |
| |
| #endif // GTEST_USES_SIMPLE_RE |
| |
| // Parses the command line for Google Test flags, without initializing |
| // other parts of Google Test. |
| GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); |
| GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); |
| |
| #if GTEST_HAS_DEATH_TEST |
| |
| // Returns the message describing the last system error, regardless of the |
| // platform. |
| GTEST_API_ std::string GetLastErrnoDescription(); |
| |
| // Attempts to parse a string into a positive integer pointed to by the |
| // number parameter. Returns true if that is possible. |
| // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use |
| // it here. |
| template <typename Integer> |
| bool ParseNaturalNumber(const ::std::string& str, Integer* number) { |
| // Fail fast if the given string does not begin with a digit; |
| // this bypasses strtoXXX's "optional leading whitespace and plus |
| // or minus sign" semantics, which are undesirable here. |
| if (str.empty() || !IsDigit(str[0])) { |
| return false; |
| } |
| errno = 0; |
| |
| char* end; |
| // BiggestConvertible is the largest integer type that system-provided |
| // string-to-number conversion routines can return. |
| |
| # if GTEST_OS_WINDOWS && !defined(__GNUC__) |
| |
| // MSVC and C++ Builder define __int64 instead of the standard long long. |
| typedef unsigned __int64 BiggestConvertible; |
| const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); |
| |
| # else |
| |
| typedef unsigned long long BiggestConvertible; // NOLINT |
| const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); |
| |
| # endif // GTEST_OS_WINDOWS && !defined(__GNUC__) |
| |
| const bool parse_success = *end == '\0' && errno == 0; |
| |
| GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); |
| |
| const Integer result = static_cast<Integer>(parsed); |
| if (parse_success && static_cast<BiggestConvertible>(result) == parsed) { |
| *number = result; |
| return true; |
| } |
| return false; |
| } |
| #endif // GTEST_HAS_DEATH_TEST |
| |
| // TestResult contains some private methods that should be hidden from |
| // Google Test user but are required for testing. This class allow our tests |
| // to access them. |
| // |
| // This class is supplied only for the purpose of testing Google Test's own |
| // constructs. Do not use it in user tests, either directly or indirectly. |
| class TestResultAccessor { |
| public: |
| static void RecordProperty(TestResult* test_result, |
| const std::string& xml_element, |
| const TestProperty& property) { |
| test_result->RecordProperty(xml_element, property); |
| } |
| |
| static void ClearTestPartResults(TestResult* test_result) { |
| test_result->ClearTestPartResults(); |
| } |
| |
| static const std::vector<testing::TestPartResult>& test_part_results( |
| const TestResult& test_result) { |
| return test_result.test_part_results(); |
| } |
| }; |
| |
| #if GTEST_CAN_STREAM_RESULTS_ |
| |
| // Streams test results to the given port on the given host machine. |
| class StreamingListener : public EmptyTestEventListener { |
| public: |
| // Abstract base class for writing strings to a socket. |
| class AbstractSocketWriter { |
| public: |
| virtual ~AbstractSocketWriter() {} |
| |
| // Sends a string to the socket. |
| virtual void Send(const std::string& message) = 0; |
| |
| // Closes the socket. |
| virtual void CloseConnection() {} |
| |
| // Sends a string and a newline to the socket. |
| void SendLn(const std::string& message) { Send(message + "\n"); } |
| }; |
| |
| // Concrete class for actually writing strings to a socket. |
| class SocketWriter : public AbstractSocketWriter { |
| public: |
| SocketWriter(const std::string& host, const std::string& port) |
| : sockfd_(-1), host_name_(host), port_num_(port) { |
| MakeConnection(); |
| } |
| |
| ~SocketWriter() override { |
| if (sockfd_ != -1) |
| CloseConnection(); |
| } |
| |
| // Sends a string to the socket. |
| void Send(const std::string& message) override { |
| GTEST_CHECK_(sockfd_ != -1) |
| << "Send() can be called only when there is a connection."; |
| |
| const int len = static_cast<int>(message.length()); |
| if (write(sockfd_, message.c_str(), len) != len) { |
| GTEST_LOG_(WARNING) |
| << "stream_result_to: failed to stream to " |
| << host_name_ << ":" << port_num_; |
| } |
| } |
| |
| private: |
| // Creates a client socket and connects to the server. |
| void MakeConnection(); |
| |
| // Closes the socket. |
| void CloseConnection() override { |
| GTEST_CHECK_(sockfd_ != -1) |
| << "CloseConnection() can be called only when there is a connection."; |
| |
| close(sockfd_); |
| sockfd_ = -1; |
| } |
| |
| int sockfd_; // socket file descriptor |
| const std::string host_name_; |
| const std::string port_num_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter); |
| }; // class SocketWriter |
| |
| // Escapes '=', '&', '%', and '\n' characters in str as "%xx". |
| static std::string UrlEncode(const char* str); |
| |
| StreamingListener(const std::string& host, const std::string& port) |
| : socket_writer_(new SocketWriter(host, port)) { |
| Start(); |
| } |
| |
| explicit StreamingListener(AbstractSocketWriter* socket_writer) |
| : socket_writer_(socket_writer) { Start(); } |
| |
| void OnTestProgramStart(const UnitTest& /* unit_test */) override { |
| SendLn("event=TestProgramStart"); |
| } |
| |
| void OnTestProgramEnd(const UnitTest& unit_test) override { |
| // Note that Google Test current only report elapsed time for each |
| // test iteration, not for the entire test program. |
| SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); |
| |
| // Notify the streaming server to stop. |
| socket_writer_->CloseConnection(); |
| } |
| |
| void OnTestIterationStart(const UnitTest& /* unit_test */, |
| int iteration) override { |
| SendLn("event=TestIterationStart&iteration=" + |
| StreamableToString(iteration)); |
| } |
| |
| void OnTestIterationEnd(const UnitTest& unit_test, |
| int /* iteration */) override { |
| SendLn("event=TestIterationEnd&passed=" + |
| FormatBool(unit_test.Passed()) + "&elapsed_time=" + |
| StreamableToString(unit_test.elapsed_time()) + "ms"); |
| } |
| |
| // Note that "event=TestCaseStart" is a wire format and has to remain |
| // "case" for compatibilty |
| void OnTestCaseStart(const TestCase& test_case) override { |
| SendLn(std::string("event=TestCaseStart&name=") + test_case.name()); |
| } |
| |
| // Note that "event=TestCaseEnd" is a wire format and has to remain |
| // "case" for compatibilty |
| void OnTestCaseEnd(const TestCase& test_case) override { |
| SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) + |
| "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) + |
| "ms"); |
| } |
| |
| void OnTestStart(const TestInfo& test_info) override { |
| SendLn(std::string("event=TestStart&name=") + test_info.name()); |
| } |
| |
| void OnTestEnd(const TestInfo& test_info) override { |
| SendLn("event=TestEnd&passed=" + |
| FormatBool((test_info.result())->Passed()) + |
| "&elapsed_time=" + |
| StreamableToString((test_info.result())->elapsed_time()) + "ms"); |
| } |
| |
| void OnTestPartResult(const TestPartResult& test_part_result) override { |
| const char* file_name = test_part_result.file_name(); |
| if (file_name == nullptr) file_name = ""; |
| SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + |
| "&line=" + StreamableToString(test_part_result.line_number()) + |
| "&message=" + UrlEncode(test_part_result.message())); |
| } |
| |
| private: |
| // Sends the given message and a newline to the socket. |
| void SendLn(const std::string& message) { socket_writer_->SendLn(message); } |
| |
| // Called at the start of streaming to notify the receiver what |
| // protocol we are using. |
| void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } |
| |
| std::string FormatBool(bool value) { return value ? "1" : "0"; } |
| |
| const std::unique_ptr<AbstractSocketWriter> socket_writer_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); |
| }; // class StreamingListener |
| |
| #endif // GTEST_CAN_STREAM_RESULTS_ |
| |
| } // namespace internal |
| } // namespace testing |
| |
| GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 |
| |
| #endif // GTEST_SRC_GTEST_INTERNAL_INL_H_ |
| |
| #if GTEST_OS_WINDOWS |
| # define vsnprintf _vsnprintf |
| #endif // GTEST_OS_WINDOWS |
| |
| #if GTEST_OS_MAC |
| #ifndef GTEST_OS_IOS |
| #include <crt_externs.h> |
| #endif |
| #endif |
| |
| #if GTEST_HAS_ABSL |
| #include "absl/debugging/failure_signal_handler.h" |
| #include "absl/debugging/stacktrace.h" |
| #include "absl/debugging/symbolize.h" |
| #include "absl/strings/str_cat.h" |
| #endif // GTEST_HAS_ABSL |
| |
| namespace testing { |
| |
| using internal::CountIf; |
| using internal::ForEach; |
| using internal::GetElementOr; |
| using internal::Shuffle; |
| |
| // Constants. |
| |
| // A test whose test suite name or test name matches this filter is |
| // disabled and not run. |
| static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; |
| |
| // A test suite whose name matches this filter is considered a death |
| // test suite and will be run before test suites whose name doesn't |
| // match this filter. |
| static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*"; |
| |
| // A test filter that matches everything. |
| static const char kUniversalFilter[] = "*"; |
| |
| // The default output format. |
| static const char kDefaultOutputFormat[] = "xml"; |
| // The default output file. |
| static const char kDefaultOutputFile[] = "test_detail"; |
| |
| // 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; |
| |
| // Utilty function to Open File for Writing |
| static FILE* OpenFileForWriting(const std::string& output_file) { |
| FILE* fileout = nullptr; |
| FilePath output_file_path(output_file); |
| FilePath output_dir(output_file_path.RemoveFileName()); |
| |
| if (output_dir.CreateDirectoriesRecursively()) { |
| fileout = posix::FOpen(output_file.c_str(), "w"); |
| } |
| if (fileout == nullptr) { |
| GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\""; |
| } |
| return fileout; |
| } |
| |
| } // namespace internal |
| |
| // Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY |
| // environment variable. |
| static const char* GetDefaultFilter() { |
| const char* const testbridge_test_only = |
| internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY"); |
| if (testbridge_test_only != nullptr) { |
| return testbridge_test_only; |
| } |
| 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_( |
| install_failure_signal_handler, |
| internal::BoolFromGTestEnv("install_failure_signal_handler", false), |
| "If true and supported on the current platform, " GTEST_NAME_ " should " |
| "install a signal handler that dumps debugging information when fatal " |
| "signals are raised."); |
| |
| GTEST_DEFINE_bool_(list_tests, false, |
| "List all tests without running them."); |
| |
| // The net priority order after flag processing is thus: |
| // --gtest_output command line flag |
| // GTEST_OUTPUT environment variable |
| // XML_OUTPUT_FILE environment variable |
| // '' |
| GTEST_DEFINE_string_( |
| output, |
| internal::StringFromGTestEnv("output", |
| internal::OutputFlagAlsoCheckEnvVar().c_str()), |
| "A format (defaults to \"xml\" but can be specified to be \"json\"), " |
| "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_bool_( |
| print_utf8, |
| internal::BoolFromGTestEnv("print_utf8", true), |
| "True iff " GTEST_NAME_ |
| " prints UTF8 characters as text."); |
| |
| 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. For use with an external test framework."); |
| |
| #if GTEST_USE_OWN_FLAGFILE_FLAG_ |
| GTEST_DEFINE_string_( |
| flagfile, |
| internal::StringFromGTestEnv("flagfile", ""), |
| "This flag specifies the flagfile to read command-line flags from."); |
| #endif // GTEST_USE_OWN_FLAGFILE_FLAG_ |
| |
| 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). |
| // Use wider types than necessary to prevent unsigned overflow diagnostics. |
| state_ = static_cast<UInt32>(1103515245ULL*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(). |
| static bool GTestIsInitialized() { return GetArgvs().size() > 0; } |
| |
| // Iterates over a vector of TestSuites, keeping a running sum of the |
| // results of calling a given int-returning method on each. |
| // Returns the sum. |
| static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list, |
| int (TestSuite::*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 suite passed. |
| static bool TestSuitePassed(const TestSuite* test_suite) { |
| return test_suite->should_run() && test_suite->Passed(); |
| } |
| |
| // Returns true iff the test suite failed. |
| static bool TestSuiteFailed(const TestSuite* test_suite) { |
| return test_suite->should_run() && test_suite->Failed(); |
| } |
| |
| // Returns true iff test_suite contains at least one test that should |
| // run. |
| static bool ShouldRunTestSuite(const TestSuite* test_suite) { |
| return test_suite->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 |
| } |
| |
| // A copy of all command line arguments. Set by InitGoogleTest(). |
| static ::std::vector<std::string> g_argvs; |
| |
| ::std::vector<std::string> GetArgvs() { |
| #if defined(GTEST_CUSTOM_GET_ARGVS_) |
| // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or |
| // ::string. This code converts it to the appropriate type. |
| const auto& custom = GTEST_CUSTOM_GET_ARGVS_(); |
| return ::std::vector<std::string>(custom.begin(), custom.end()); |
| #else // defined(GTEST_CUSTOM_GET_ARGVS_) |
| return g_argvs; |
| #endif // defined(GTEST_CUSTOM_GET_ARGVS_) |
| } |
| |
| // Returns the current application's name, removing directory path if that |
| // is present. |
| FilePath GetCurrentExecutableName() { |
| FilePath result; |
| |
| #if GTEST_OS_WINDOWS || GTEST_OS_OS2 |
| result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe")); |
| #else |
| result.Set(FilePath(GetArgvs()[0])); |
| #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(); |
| const char* const colon = strchr(gtest_output_flag, ':'); |
| return (colon == nullptr) |
| ? 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(); |
| |
| std::string format = GetOutputFormat(); |
| if (format.empty()) |
| format = std::string(kDefaultOutputFormat); |
| |
| const char* const colon = strchr(gtest_output_flag, ':'); |
| if (colon == nullptr) |
| return internal::FilePath::MakeFileName( |
| internal::FilePath( |
| UnitTest::GetInstance()->original_working_dir()), |
| internal::FilePath(kDefaultOutputFile), 0, |
| format.c_str()).string(); |
| |
| internal::FilePath output_name(colon + 1); |
| if (!output_name.IsAbsolutePath()) |
| 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 == nullptr) { |
| return false; |
| } |
| |
| // Skips the pattern separater (the ':' character). |
| cur_pattern++; |
| } |
| } |
| |
| // Returns true iff the user-specified filter matches the test suite |
| // name and the test name. |
| bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name, |
| const std::string& test_name) { |
| const std::string& full_name = test_suite_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 == nullptr) { |
| 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<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. |
| static AssertionResult HasOneFailure(const char* /* results_expr */, |
| const char* /* type_expr */, |
| const char* /* substr_expr */, |
| const TestPartResultArray& results, |
| TestPartResult::Type type, |
| const std::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()) == nullptr) { |
| 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 std::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 suites. |
| int UnitTestImpl::successful_test_suite_count() const { |
| return CountIf(test_suites_, TestSuitePassed); |
| } |
| |
| // Gets the number of failed test suites. |
| int UnitTestImpl::failed_test_suite_count() const { |
| return CountIf(test_suites_, TestSuiteFailed); |
| } |
| |
| // Gets the number of all test suites. |
| int UnitTestImpl::total_test_suite_count() const { |
| return static_cast<int>(test_suites_.size()); |
| } |
| |
| // Gets the number of all test suites that contain at least one test |
| // that should run. |
| int UnitTestImpl::test_suite_to_run_count() const { |
| return CountIf(test_suites_, ShouldRunTestSuite); |
| } |
| |
| // Gets the number of successful tests. |
| int UnitTestImpl::successful_test_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count); |
| } |
| |
| // Gets the number of skipped tests. |
| int UnitTestImpl::skipped_test_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count); |
| } |
| |
| // Gets the number of failed tests. |
| int UnitTestImpl::failed_test_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::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 SumOverTestSuiteList(test_suites_, |
| &TestSuite::reportable_disabled_test_count); |
| } |
| |
| // Gets the number of disabled tests. |
| int UnitTestImpl::disabled_test_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count); |
| } |
| |
| // Gets the number of tests to be printed in the XML report. |
| int UnitTestImpl::reportable_test_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count); |
| } |
| |
| // Gets the number of all tests. |
| int UnitTestImpl::total_test_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count); |
| } |
| |
| // Gets the number of tests that should run. |
| int UnitTestImpl::test_to_run_count() const { |
| return SumOverTestSuiteList(test_suites_, &TestSuite::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) { |
| return os_stack_trace_getter()->CurrentStackTrace( |
| static_cast<int>(GTEST_FLAG(stack_trace_depth)), |
| skip_count + 1 |
| // Skips the user-specified number of frames plus this function |
| // itself. |
| ); // NOLINT |
| } |
| |
| // 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; |
| 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; |
| |
| // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 |
| // (deprecated function) there. |
| GTEST_DISABLE_MSC_DEPRECATED_PUSH_() |
| _ftime64(&now); |
| GTEST_DISABLE_MSC_DEPRECATED_POP_() |
| |
| return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; |
| #elif GTEST_HAS_GETTIMEOFDAY_ |
| struct timeval now; |
| gettimeofday(&now, nullptr); |
| 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. |
| |
| #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 nullptr; |
| const int length = strlen(ansi); |
| const int unicode_length = |
| MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 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 nullptr; |
| const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr, |
| 0, nullptr, nullptr); |
| char* ansi = new char[ansi_length + 1]; |
| WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr, |
| nullptr); |
| 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 == nullptr) return rhs == nullptr; |
| |
| if (rhs == nullptr) 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<int>(length - i)); |
| while (i != length && wstr[i] != L'\0') |
| i++; |
| } else { |
| *msg << '\0'; |
| i++; |
| } |
| } |
| } |
| |
| #endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING |
| |
| void SplitString(const ::std::string& str, char delimiter, |
| ::std::vector< ::std::string>* dest) { |
| ::std::vector< ::std::string> parsed; |
| ::std::string::size_type pos = 0; |
| while (::testing::internal::AlwaysTrue()) { |
| const ::std::string::size_type colon = str.find(delimiter, pos); |
| if (colon == ::std::string::npos) { |
| parsed.push_back(str.substr(pos)); |
| break; |
| } else { |
| parsed.push_back(str.substr(pos, colon - pos)); |
| pos = colon + 1; |
| } |
| } |
| dest->swap(parsed); |
| } |
| |
| } // 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<double>::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() != nullptr |
| ? new ::std::string(*other.message_) |
| : static_cast< ::std::string*>(nullptr)) {} |
| |
| // Swaps two AssertionResults. |
| void AssertionResult::swap(AssertionResult& other) { |
| using std::swap; |
| swap(success_, other.success_); |
| swap(message_, other.message_); |
| } |
| |
| // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. |
| AssertionResult AssertionResult::operator!() const { |
| AssertionResult negation(!success_); |
| if (message_.get() != nullptr) 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 { |
| |
| namespace edit_distance { |
| std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left, |
| const std::vector<size_t>& right) { |
| std::vector<std::vector<double> > costs( |
| left.size() + 1, std::vector<double>(right.size() + 1)); |
| std::vector<std::vector<EditType> > best_move( |
| left.size() + 1, std::vector<EditType>(right.size() + 1)); |
| |
| // Populate for empty right. |
| for (size_t l_i = 0; l_i < costs.size(); ++l_i) { |
| costs[l_i][0] = static_cast<double>(l_i); |
| best_move[l_i][0] = kRemove; |
| } |
| // Populate for empty left. |
| for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) { |
| costs[0][r_i] = static_cast<double>(r_i); |
| best_move[0][r_i] = kAdd; |
| } |
| |
| for (size_t l_i = 0; l_i < left.size(); ++l_i) { |
| for (size_t r_i = 0; r_i < right.size(); ++r_i) { |
| if (left[l_i] == right[r_i]) { |
| // Found a match. Consume it. |
| costs[l_i + 1][r_i + 1] = costs[l_i][r_i]; |
| best_move[l_i + 1][r_i + 1] = kMatch; |
| continue; |
| } |
| |
| const double add = costs[l_i + 1][r_i]; |
| const double remove = costs[l_i][r_i + 1]; |
| const double replace = costs[l_i][r_i]; |
| if (add < remove && add < replace) { |
| costs[l_i + 1][r_i + 1] = add + 1; |
| best_move[l_i + 1][r_i + 1] = kAdd; |
| } else if (remove < add && remove < replace) { |
| costs[l_i + 1][r_i + 1] = remove + 1; |
| best_move[l_i + 1][r_i + 1] = kRemove; |
| } else { |
| // We make replace a little more expensive than add/remove to lower |
| // their priority. |
| costs[l_i + 1][r_i + 1] = replace + 1.00001; |
| best_move[l_i + 1][r_i + 1] = kReplace; |
| } |
| } |
| } |
| |
| // Reconstruct the best path. We do it in reverse order. |
| std::vector<EditType> best_path; |
| for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) { |
| EditType move = best_move[l_i][r_i]; |
| best_path.push_back(move); |
| l_i -= move != kAdd; |
| r_i -= move != kRemove; |
| } |
| std::reverse(best_path.begin(), best_path.end()); |
| return best_path; |
| } |
| |
| namespace { |
| |
| // Helper class to convert string into ids with deduplication. |
| class InternalStrings { |
| public: |
| size_t GetId(const std::string& str) { |
| IdMap::iterator it = ids_.find(str); |
| if (it != ids_.end()) return it->second; |
| size_t id = ids_.size(); |
| return ids_[str] = id; |
| } |
| |
| private: |
| typedef std::map<std::string, size_t> IdMap; |
| IdMap ids_; |
| }; |
| |
| } // namespace |
| |
| std::vector<EditType> CalculateOptimalEdits( |
| const std::vector<std::string>& left, |
| const std::vector<std::string>& right) { |
| std::vector<size_t> left_ids, right_ids; |
| { |
| InternalStrings intern_table; |
| for (size_t i = 0; i < left.size(); ++i) { |
| left_ids.push_back(intern_table.GetId(left[i])); |
| } |
| for (size_t i = 0; i < right.size(); ++i) { |
| right_ids.push_back(intern_table.GetId(right[i])); |
| } |
| } |
| return CalculateOptimalEdits(left_ids, right_ids); |
| } |
| |
| namespace { |
| |
| // Helper class that holds the state for one hunk and prints it out to the |
| // stream. |
| // It reorders adds/removes when possible to group all removes before all |
| // adds. It also adds the hunk header before printint into the stream. |
| class Hunk { |
| public: |
| Hunk(size_t left_start, size_t right_start) |
| : left_start_(left_start), |
| right_start_(right_start), |
| adds_(), |
| removes_(), |
| common_() {} |
| |
| void PushLine(char edit, const char* line) { |
| switch (edit) { |
| case ' ': |
| ++common_; |
| FlushEdits(); |
| hunk_.push_back(std::make_pair(' ', line)); |
| break; |
| case '-': |
| ++removes_; |
| hunk_removes_.push_back(std::make_pair('-', line)); |
| break; |
| case '+': |
| ++adds_; |
| hunk_adds_.push_back(std::make_pair('+', line)); |
| break; |
| } |
| } |
| |
| void PrintTo(std::ostream* os) { |
| PrintHeader(os); |
| FlushEdits(); |
| for (std::list<std::pair<char, const char*> >::const_iterator it = |
| hunk_.begin(); |
| it != hunk_.end(); ++it) { |
| *os << it->first << it->second << "\n"; |
| } |
| } |
| |
| bool has_edits() const { return adds_ || removes_; } |
| |
| private: |
| void FlushEdits() { |
| hunk_.splice(hunk_.end(), hunk_removes_); |
| hunk_.splice(hunk_.end(), hunk_adds_); |
| } |
| |
| // Print a unified diff header for one hunk. |
| // The format is |
| // "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@" |
| // where the left/right parts are omitted if unnecessary. |
| void PrintHeader(std::ostream* ss) const { |
| *ss << "@@ "; |
| if (removes_) { |
| *ss << "-" << left_start_ << "," << (removes_ + common_); |
| } |
| if (removes_ && adds_) { |
| *ss << " "; |
| } |
| if (adds_) { |
| *ss << "+" << right_start_ << "," << (adds_ + common_); |
| } |
| *ss << " @@\n"; |
| } |
| |
| size_t left_start_, right_start_; |
| size_t adds_, removes_, common_; |
| std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_; |
| }; |
| |
| } // namespace |
| |
| // Create a list of diff hunks in Unified diff format. |
| // Each hunk has a header generated by PrintHeader above plus a body with |
| // lines prefixed with ' ' for no change, '-' for deletion and '+' for |
| // addition. |
| // 'context' represents the desired unchanged prefix/suffix around the diff. |
| // If two hunks are close enough that their contexts overlap, then they are |
| // joined into one hunk. |
| std::string CreateUnifiedDiff(const std::vector<std::string>& left, |
| const std::vector<std::string>& right, |
| size_t context) { |
| const std::vector<EditType> edits = CalculateOptimalEdits(left, right); |
| |
| size_t l_i = 0, r_i = 0, edit_i = 0; |
| std::stringstream ss; |
| while (edit_i < edits.size()) { |
| // Find first edit. |
| while (edit_i < edits.size() && edits[edit_i] == kMatch) { |
| ++l_i; |
| ++r_i; |
| ++edit_i; |
| } |
| |
| // Find the first line to include in the hunk. |
| const size_t prefix_context = std::min(l_i, context); |
| Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1); |
| for (size_t i = prefix_context; i > 0; --i) { |
| hunk.PushLine(' ', left[l_i - i].c_str()); |
| } |
| |
| // Iterate the edits until we found enough suffix for the hunk or the input |
| // is over. |
| size_t n_suffix = 0; |
| for (; edit_i < edits.size(); ++edit_i) { |
| if (n_suffix >= context) { |
| // Continue only if the next hunk is very close. |
| std::vector<EditType>::const_iterator it = edits.begin() + edit_i; |
| while (it != edits.end() && *it == kMatch) ++it; |
| if (it == edits.end() || (it - edits.begin()) - edit_i >= context) { |
| // There is no next edit or it is too far away. |
| break; |
| } |
| } |
| |
| EditType edit = edits[edit_i]; |
| // Reset count when a non match is found. |
| n_suffix = edit == kMatch ? n_suffix + 1 : 0; |
| |
| if (edit == kMatch || edit == kRemove || edit == kReplace) { |
| hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str()); |
| } |
| if (edit == kAdd || edit == kReplace) { |
| hunk.PushLine('+', right[r_i].c_str()); |
| } |
| |
| // Advance indices, depending on edit type. |
| l_i += edit != kAdd; |
| r_i += edit != kRemove; |
| } |
| |
| if (!hunk.has_edits()) { |
| // We are done. We don't want this hunk. |
| break; |
| } |
| |
| hunk.PrintTo(&ss); |
| } |
| return ss.str(); |
| } |
| |
| } // namespace edit_distance |
| |
| namespace { |
| |
| // The string representation of the values received in EqFailure() are already |
| // escaped. Split them on escaped '\n' boundaries. Leave all other escaped |
| // characters the same. |
| std::vector<std::string> SplitEscapedString(const std::string& str) { |
| std::vector<std::string> lines; |
| size_t start = 0, end = str.size(); |
| if (end > 2 && str[0] == '"' && str[end - 1] == '"') { |
| ++start; |
| --end; |
| } |
| bool escaped = false; |
| for (size_t i = start; i + 1 < end; ++i) { |
| if (escaped) { |
| escaped = false; |
| if (str[i] == 'n') { |
| lines.push_back(str.substr(start, i - start - 1)); |
| start = i + 1; |
| } |
| } else { |
| escaped = str[i] == '\\'; |
| } |
| } |
| lines.push_back(str.substr(start, end - start)); |
| return lines; |
| } |
| |
| } // namespace |
| |
| // 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: |
| // |
| // lhs_expression: "foo" |
| // rhs_expression: "bar" |
| // lhs_value: "5" |
| // rhs_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* lhs_expression, |
| const char* rhs_expression, |
| const std::string& lhs_value, |
| const std::string& rhs_value, |
| bool ignoring_case) { |
| Message msg; |
| msg << "Expected equality of these values:"; |
| msg << "\n " << lhs_expression; |
| if (lhs_value != lhs_expression) { |
| msg << "\n Which is: " << lhs_value; |
| } |
| msg << "\n " << rhs_expression; |
| if (rhs_value != rhs_expression) { |
| msg << "\n Which is: " << rhs_value; |
| } |
| |
| if (ignoring_case) { |
| msg << "\nIgnoring case"; |
| } |
| |
| if (!lhs_value.empty() && !rhs_value.empty()) { |
| const std::vector<std::string> lhs_lines = |
| SplitEscapedString(lhs_value); |
| const std::vector<std::string> rhs_lines = |
| SplitEscapedString(rhs_value); |
| if (lhs_lines.size() > 1 || rhs_lines.size() > 1) { |
| msg << "\nWith diff:\n" |
| << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines); |
| } |
| } |
| |
| 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(); |
| |
| 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 <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. |
| |
| ::std::stringstream val1_ss; |
| val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) |
| << val1; |
| |
| ::std::stringstream val2_ss; |
| val2_ss << std::setprecision(std::numeric_limits<RawType>::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<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* lhs_expression, |
| const char* rhs_expression, |
| BiggestInt lhs, |
| BiggestInt rhs) { |
| if (lhs == rhs) { |
| return AssertionSuccess(); |
| } |
| |
| return EqFailure(lhs_expression, |
| rhs_expression, |
| FormatForComparisonFailureMessage(lhs, rhs), |
| FormatForComparisonFailureMessage(rhs, lhs), |
| 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 {\ |
| return AssertionFailure() \ |
| << "Expected: (" << expr1 << ") " #op " (" << expr2\ |
| << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ |
| << " vs " << FormatForComparisonFailureMessage(val2, val1);\ |
| }\ |
| } |
| |
| // 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* lhs_expression, |
| const char* rhs_expression, |
| const char* lhs, |
| const char* rhs) { |
| if (String::CStringEquals(lhs, rhs)) { |
| return AssertionSuccess(); |
| } |
| |
| return EqFailure(lhs_expression, |
| rhs_expression, |
| PrintToString(lhs), |
| PrintToString(rhs), |
| false); |
| } |
| |
| // The helper function for {ASSERT|EXPECT}_STRCASEEQ. |
| AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression, |
| const char* rhs_expression, |
| const char* lhs, |
| const char* rhs) { |
| if (String::CaseInsensitiveCStringEquals(lhs, rhs)) { |
| return AssertionSuccess(); |
| } |
| |
| return EqFailure(lhs_expression, |
| rhs_expression, |
| PrintToString(lhs), |
| PrintToString(rhs), |
| 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 { |
| return AssertionFailure() << "Expected: (" << s1_expression << ") != (" |
| << s2_expression << "), actual: \"" |
| << s1 << "\" vs \"" << s2 << "\""; |
| } |
| } |
| |
| // 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 { |
| return AssertionFailure() |
| << "Expected: (" << s1_expression << ") != (" |
| << s2_expression << ") (ignoring case), actual: \"" |
| << s1 << "\" vs \"" << s2 << "\""; |
| } |
| } |
| |
| } // 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 == nullptr || haystack == nullptr) return needle == haystack; |
| |
| return strstr(haystack, needle) != nullptr; |
| } |
| |
| bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { |
| if (needle == nullptr || haystack == nullptr) return needle == haystack; |
| |
| return wcsstr(haystack, needle) != nullptr; |
| } |
| |
| // 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() |
| << "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, |
|