[12175] | 1 | // Copyright 2005, Google Inc. |
---|
| 2 | // All rights reserved. |
---|
| 3 | // |
---|
| 4 | // Redistribution and use in source and binary forms, with or without |
---|
| 5 | // modification, are permitted provided that the following conditions are |
---|
| 6 | // met: |
---|
| 7 | // |
---|
| 8 | // * Redistributions of source code must retain the above copyright |
---|
| 9 | // notice, this list of conditions and the following disclaimer. |
---|
| 10 | // * Redistributions in binary form must reproduce the above |
---|
| 11 | // copyright notice, this list of conditions and the following disclaimer |
---|
| 12 | // in the documentation and/or other materials provided with the |
---|
| 13 | // distribution. |
---|
| 14 | // * Neither the name of Google Inc. nor the names of its |
---|
| 15 | // contributors may be used to endorse or promote products derived from |
---|
| 16 | // this software without specific prior written permission. |
---|
| 17 | // |
---|
| 18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
---|
| 19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
---|
| 20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
---|
| 21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
---|
| 22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
---|
| 23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
---|
| 24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
---|
| 25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
---|
| 26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
---|
| 27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
---|
| 28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
---|
| 29 | // |
---|
| 30 | // Author: wan@google.com (Zhanyong Wan) |
---|
| 31 | // |
---|
| 32 | // The Google C++ Testing Framework (Google Test) |
---|
| 33 | |
---|
| 34 | #include "gtest/gtest.h" |
---|
| 35 | #include "gtest/gtest-spi.h" |
---|
| 36 | |
---|
| 37 | #include <ctype.h> |
---|
| 38 | #include <math.h> |
---|
| 39 | #include <stdarg.h> |
---|
| 40 | #include <stdio.h> |
---|
| 41 | #include <stdlib.h> |
---|
| 42 | #include <wchar.h> |
---|
| 43 | #include <wctype.h> |
---|
| 44 | |
---|
| 45 | #include <algorithm> |
---|
| 46 | #include <ostream> // NOLINT |
---|
| 47 | #include <sstream> |
---|
| 48 | #include <vector> |
---|
| 49 | |
---|
| 50 | #if GTEST_OS_LINUX |
---|
| 51 | |
---|
| 52 | // TODO(kenton@google.com): Use autoconf to detect availability of |
---|
| 53 | // gettimeofday(). |
---|
| 54 | # define GTEST_HAS_GETTIMEOFDAY_ 1 |
---|
| 55 | |
---|
| 56 | # include <fcntl.h> // NOLINT |
---|
| 57 | # include <limits.h> // NOLINT |
---|
| 58 | # include <sched.h> // NOLINT |
---|
| 59 | // Declares vsnprintf(). This header is not available on Windows. |
---|
| 60 | # include <strings.h> // NOLINT |
---|
| 61 | # include <sys/mman.h> // NOLINT |
---|
| 62 | # include <sys/time.h> // NOLINT |
---|
| 63 | # include <unistd.h> // NOLINT |
---|
| 64 | # include <string> |
---|
| 65 | |
---|
| 66 | #elif GTEST_OS_SYMBIAN |
---|
| 67 | # define GTEST_HAS_GETTIMEOFDAY_ 1 |
---|
| 68 | # include <sys/time.h> // NOLINT |
---|
| 69 | |
---|
| 70 | #elif GTEST_OS_ZOS |
---|
| 71 | # define GTEST_HAS_GETTIMEOFDAY_ 1 |
---|
| 72 | # include <sys/time.h> // NOLINT |
---|
| 73 | |
---|
| 74 | // On z/OS we additionally need strings.h for strcasecmp. |
---|
| 75 | # include <strings.h> // NOLINT |
---|
| 76 | |
---|
| 77 | #elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. |
---|
| 78 | |
---|
| 79 | # include <windows.h> // NOLINT |
---|
| 80 | |
---|
| 81 | #elif GTEST_OS_WINDOWS // We are on Windows proper. |
---|
| 82 | |
---|
| 83 | # include <io.h> // NOLINT |
---|
| 84 | # include <sys/timeb.h> // NOLINT |
---|
| 85 | # include <sys/types.h> // NOLINT |
---|
| 86 | # include <sys/stat.h> // NOLINT |
---|
| 87 | |
---|
| 88 | # if GTEST_OS_WINDOWS_MINGW |
---|
| 89 | // MinGW has gettimeofday() but not _ftime64(). |
---|
| 90 | // TODO(kenton@google.com): Use autoconf to detect availability of |
---|
| 91 | // gettimeofday(). |
---|
| 92 | // TODO(kenton@google.com): There are other ways to get the time on |
---|
| 93 | // Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW |
---|
| 94 | // supports these. consider using them instead. |
---|
| 95 | # define GTEST_HAS_GETTIMEOFDAY_ 1 |
---|
| 96 | # include <sys/time.h> // NOLINT |
---|
| 97 | # endif // GTEST_OS_WINDOWS_MINGW |
---|
| 98 | |
---|
| 99 | // cpplint thinks that the header is already included, so we want to |
---|
| 100 | // silence it. |
---|
| 101 | # include <windows.h> // NOLINT |
---|
| 102 | |
---|
| 103 | #else |
---|
| 104 | |
---|
| 105 | // Assume other platforms have gettimeofday(). |
---|
| 106 | // TODO(kenton@google.com): Use autoconf to detect availability of |
---|
| 107 | // gettimeofday(). |
---|
| 108 | # define GTEST_HAS_GETTIMEOFDAY_ 1 |
---|
| 109 | |
---|
| 110 | // cpplint thinks that the header is already included, so we want to |
---|
| 111 | // silence it. |
---|
| 112 | # include <sys/time.h> // NOLINT |
---|
| 113 | # include <unistd.h> // NOLINT |
---|
| 114 | |
---|
| 115 | #endif // GTEST_OS_LINUX |
---|
| 116 | |
---|
| 117 | #if GTEST_HAS_EXCEPTIONS |
---|
| 118 | # include <stdexcept> |
---|
| 119 | #endif |
---|
| 120 | |
---|
| 121 | #if GTEST_CAN_STREAM_RESULTS_ |
---|
| 122 | # include <arpa/inet.h> // NOLINT |
---|
| 123 | # include <netdb.h> // NOLINT |
---|
| 124 | #endif |
---|
| 125 | |
---|
| 126 | // Indicates that this translation unit is part of Google Test's |
---|
| 127 | // implementation. It must come before gtest-internal-inl.h is |
---|
| 128 | // included, or there will be a compiler error. This trick is to |
---|
| 129 | // prevent a user from accidentally including gtest-internal-inl.h in |
---|
| 130 | // his code. |
---|
| 131 | #define GTEST_IMPLEMENTATION_ 1 |
---|
| 132 | #include "src/gtest-internal-inl.h" |
---|
| 133 | #undef GTEST_IMPLEMENTATION_ |
---|
| 134 | |
---|
| 135 | #if GTEST_OS_WINDOWS |
---|
| 136 | # define vsnprintf _vsnprintf |
---|
| 137 | #endif // GTEST_OS_WINDOWS |
---|
| 138 | |
---|
| 139 | namespace testing { |
---|
| 140 | |
---|
| 141 | using internal::CountIf; |
---|
| 142 | using internal::ForEach; |
---|
| 143 | using internal::GetElementOr; |
---|
| 144 | using internal::Shuffle; |
---|
| 145 | |
---|
| 146 | // Constants. |
---|
| 147 | |
---|
| 148 | // A test whose test case name or test name matches this filter is |
---|
| 149 | // disabled and not run. |
---|
| 150 | static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; |
---|
| 151 | |
---|
| 152 | // A test case whose name matches this filter is considered a death |
---|
| 153 | // test case and will be run before test cases whose name doesn't |
---|
| 154 | // match this filter. |
---|
| 155 | static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"; |
---|
| 156 | |
---|
| 157 | // A test filter that matches everything. |
---|
| 158 | static const char kUniversalFilter[] = "*"; |
---|
| 159 | |
---|
| 160 | // The default output file for XML output. |
---|
| 161 | static const char kDefaultOutputFile[] = "test_detail.xml"; |
---|
| 162 | |
---|
| 163 | // The environment variable name for the test shard index. |
---|
| 164 | static const char kTestShardIndex[] = "GTEST_SHARD_INDEX"; |
---|
| 165 | // The environment variable name for the total number of test shards. |
---|
| 166 | static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS"; |
---|
| 167 | // The environment variable name for the test shard status file. |
---|
| 168 | static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"; |
---|
| 169 | |
---|
| 170 | namespace internal { |
---|
| 171 | |
---|
| 172 | // The text used in failure messages to indicate the start of the |
---|
| 173 | // stack trace. |
---|
| 174 | const char kStackTraceMarker[] = "\nStack trace:\n"; |
---|
| 175 | |
---|
| 176 | // g_help_flag is true iff the --help flag or an equivalent form is |
---|
| 177 | // specified on the command line. |
---|
| 178 | bool g_help_flag = false; |
---|
| 179 | |
---|
| 180 | } // namespace internal |
---|
| 181 | |
---|
| 182 | GTEST_DEFINE_bool_( |
---|
| 183 | also_run_disabled_tests, |
---|
| 184 | internal::BoolFromGTestEnv("also_run_disabled_tests", false), |
---|
| 185 | "Run disabled tests too, in addition to the tests normally being run."); |
---|
| 186 | |
---|
| 187 | GTEST_DEFINE_bool_( |
---|
| 188 | break_on_failure, |
---|
| 189 | internal::BoolFromGTestEnv("break_on_failure", false), |
---|
| 190 | "True iff a failed assertion should be a debugger break-point."); |
---|
| 191 | |
---|
| 192 | GTEST_DEFINE_bool_( |
---|
| 193 | catch_exceptions, |
---|
| 194 | internal::BoolFromGTestEnv("catch_exceptions", true), |
---|
| 195 | "True iff " GTEST_NAME_ |
---|
| 196 | " should catch exceptions and treat them as test failures."); |
---|
| 197 | |
---|
| 198 | GTEST_DEFINE_string_( |
---|
| 199 | color, |
---|
| 200 | internal::StringFromGTestEnv("color", "auto"), |
---|
| 201 | "Whether to use colors in the output. Valid values: yes, no, " |
---|
| 202 | "and auto. 'auto' means to use colors if the output is " |
---|
| 203 | "being sent to a terminal and the TERM environment variable " |
---|
| 204 | "is set to xterm, xterm-color, xterm-256color, linux or cygwin."); |
---|
| 205 | |
---|
| 206 | GTEST_DEFINE_string_( |
---|
| 207 | filter, |
---|
| 208 | internal::StringFromGTestEnv("filter", kUniversalFilter), |
---|
| 209 | "A colon-separated list of glob (not regex) patterns " |
---|
| 210 | "for filtering the tests to run, optionally followed by a " |
---|
| 211 | "'-' and a : separated list of negative patterns (tests to " |
---|
| 212 | "exclude). A test is run if it matches one of the positive " |
---|
| 213 | "patterns and does not match any of the negative patterns."); |
---|
| 214 | |
---|
| 215 | GTEST_DEFINE_bool_(list_tests, false, |
---|
| 216 | "List all tests without running them."); |
---|
| 217 | |
---|
| 218 | GTEST_DEFINE_string_( |
---|
| 219 | output, |
---|
| 220 | internal::StringFromGTestEnv("output", ""), |
---|
| 221 | "A format (currently must be \"xml\"), optionally followed " |
---|
| 222 | "by a colon and an output file name or directory. A directory " |
---|
| 223 | "is indicated by a trailing pathname separator. " |
---|
| 224 | "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " |
---|
| 225 | "If a directory is specified, output files will be created " |
---|
| 226 | "within that directory, with file-names based on the test " |
---|
| 227 | "executable's name and, if necessary, made unique by adding " |
---|
| 228 | "digits."); |
---|
| 229 | |
---|
| 230 | GTEST_DEFINE_bool_( |
---|
| 231 | print_time, |
---|
| 232 | internal::BoolFromGTestEnv("print_time", true), |
---|
| 233 | "True iff " GTEST_NAME_ |
---|
| 234 | " should display elapsed time in text output."); |
---|
| 235 | |
---|
| 236 | GTEST_DEFINE_int32_( |
---|
| 237 | random_seed, |
---|
| 238 | internal::Int32FromGTestEnv("random_seed", 0), |
---|
| 239 | "Random number seed to use when shuffling test orders. Must be in range " |
---|
| 240 | "[1, 99999], or 0 to use a seed based on the current time."); |
---|
| 241 | |
---|
| 242 | GTEST_DEFINE_int32_( |
---|
| 243 | repeat, |
---|
| 244 | internal::Int32FromGTestEnv("repeat", 1), |
---|
| 245 | "How many times to repeat each test. Specify a negative number " |
---|
| 246 | "for repeating forever. Useful for shaking out flaky tests."); |
---|
| 247 | |
---|
| 248 | GTEST_DEFINE_bool_( |
---|
| 249 | show_internal_stack_frames, false, |
---|
| 250 | "True iff " GTEST_NAME_ " should include internal stack frames when " |
---|
| 251 | "printing test failure stack traces."); |
---|
| 252 | |
---|
| 253 | GTEST_DEFINE_bool_( |
---|
| 254 | shuffle, |
---|
| 255 | internal::BoolFromGTestEnv("shuffle", false), |
---|
| 256 | "True iff " GTEST_NAME_ |
---|
| 257 | " should randomize tests' order on every run."); |
---|
| 258 | |
---|
| 259 | GTEST_DEFINE_int32_( |
---|
| 260 | stack_trace_depth, |
---|
| 261 | internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), |
---|
| 262 | "The maximum number of stack frames to print when an " |
---|
| 263 | "assertion fails. The valid range is 0 through 100, inclusive."); |
---|
| 264 | |
---|
| 265 | GTEST_DEFINE_string_( |
---|
| 266 | stream_result_to, |
---|
| 267 | internal::StringFromGTestEnv("stream_result_to", ""), |
---|
| 268 | "This flag specifies the host name and the port number on which to stream " |
---|
| 269 | "test results. Example: \"localhost:555\". The flag is effective only on " |
---|
| 270 | "Linux."); |
---|
| 271 | |
---|
| 272 | GTEST_DEFINE_bool_( |
---|
| 273 | throw_on_failure, |
---|
| 274 | internal::BoolFromGTestEnv("throw_on_failure", false), |
---|
| 275 | "When this flag is specified, a failed assertion will throw an exception " |
---|
| 276 | "if exceptions are enabled or exit the program with a non-zero code " |
---|
| 277 | "otherwise."); |
---|
| 278 | |
---|
| 279 | namespace internal { |
---|
| 280 | |
---|
| 281 | // Generates a random number from [0, range), using a Linear |
---|
| 282 | // Congruential Generator (LCG). Crashes if 'range' is 0 or greater |
---|
| 283 | // than kMaxRange. |
---|
| 284 | UInt32 Random::Generate(UInt32 range) { |
---|
| 285 | // These constants are the same as are used in glibc's rand(3). |
---|
| 286 | state_ = (1103515245U*state_ + 12345U) % kMaxRange; |
---|
| 287 | |
---|
| 288 | GTEST_CHECK_(range > 0) |
---|
| 289 | << "Cannot generate a number in the range [0, 0)."; |
---|
| 290 | GTEST_CHECK_(range <= kMaxRange) |
---|
| 291 | << "Generation of a number in [0, " << range << ") was requested, " |
---|
| 292 | << "but this can only generate numbers in [0, " << kMaxRange << ")."; |
---|
| 293 | |
---|
| 294 | // Converting via modulus introduces a bit of downward bias, but |
---|
| 295 | // it's simple, and a linear congruential generator isn't too good |
---|
| 296 | // to begin with. |
---|
| 297 | return state_ % range; |
---|
| 298 | } |
---|
| 299 | |
---|
| 300 | // GTestIsInitialized() returns true iff the user has initialized |
---|
| 301 | // Google Test. Useful for catching the user mistake of not initializing |
---|
| 302 | // Google Test before calling RUN_ALL_TESTS(). |
---|
| 303 | // |
---|
| 304 | // A user must call testing::InitGoogleTest() to initialize Google |
---|
| 305 | // Test. g_init_gtest_count is set to the number of times |
---|
| 306 | // InitGoogleTest() has been called. We don't protect this variable |
---|
| 307 | // under a mutex as it is only accessed in the main thread. |
---|
| 308 | int g_init_gtest_count = 0; |
---|
| 309 | static bool GTestIsInitialized() { return g_init_gtest_count != 0; } |
---|
| 310 | |
---|
| 311 | // Iterates over a vector of TestCases, keeping a running sum of the |
---|
| 312 | // results of calling a given int-returning method on each. |
---|
| 313 | // Returns the sum. |
---|
| 314 | static int SumOverTestCaseList(const std::vector<TestCase*>& case_list, |
---|
| 315 | int (TestCase::*method)() const) { |
---|
| 316 | int sum = 0; |
---|
| 317 | for (size_t i = 0; i < case_list.size(); i++) { |
---|
| 318 | sum += (case_list[i]->*method)(); |
---|
| 319 | } |
---|
| 320 | return sum; |
---|
| 321 | } |
---|
| 322 | |
---|
| 323 | // Returns true iff the test case passed. |
---|
| 324 | static bool TestCasePassed(const TestCase* test_case) { |
---|
| 325 | return test_case->should_run() && test_case->Passed(); |
---|
| 326 | } |
---|
| 327 | |
---|
| 328 | // Returns true iff the test case failed. |
---|
| 329 | static bool TestCaseFailed(const TestCase* test_case) { |
---|
| 330 | return test_case->should_run() && test_case->Failed(); |
---|
| 331 | } |
---|
| 332 | |
---|
| 333 | // Returns true iff test_case contains at least one test that should |
---|
| 334 | // run. |
---|
| 335 | static bool ShouldRunTestCase(const TestCase* test_case) { |
---|
| 336 | return test_case->should_run(); |
---|
| 337 | } |
---|
| 338 | |
---|
| 339 | // AssertHelper constructor. |
---|
| 340 | AssertHelper::AssertHelper(TestPartResult::Type type, |
---|
| 341 | const char* file, |
---|
| 342 | int line, |
---|
| 343 | const char* message) |
---|
| 344 | : data_(new AssertHelperData(type, file, line, message)) { |
---|
| 345 | } |
---|
| 346 | |
---|
| 347 | AssertHelper::~AssertHelper() { |
---|
| 348 | delete data_; |
---|
| 349 | } |
---|
| 350 | |
---|
| 351 | // Message assignment, for assertion streaming support. |
---|
| 352 | void AssertHelper::operator=(const Message& message) const { |
---|
| 353 | UnitTest::GetInstance()-> |
---|
| 354 | AddTestPartResult(data_->type, data_->file, data_->line, |
---|
| 355 | AppendUserMessage(data_->message, message), |
---|
| 356 | UnitTest::GetInstance()->impl() |
---|
| 357 | ->CurrentOsStackTraceExceptTop(1) |
---|
| 358 | // Skips the stack frame for this function itself. |
---|
| 359 | ); // NOLINT |
---|
| 360 | } |
---|
| 361 | |
---|
| 362 | // Mutex for linked pointers. |
---|
| 363 | GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex); |
---|
| 364 | |
---|
| 365 | // Application pathname gotten in InitGoogleTest. |
---|
| 366 | String g_executable_path; |
---|
| 367 | |
---|
| 368 | // Returns the current application's name, removing directory path if that |
---|
| 369 | // is present. |
---|
| 370 | FilePath GetCurrentExecutableName() { |
---|
| 371 | FilePath result; |
---|
| 372 | |
---|
| 373 | #if GTEST_OS_WINDOWS |
---|
| 374 | result.Set(FilePath(g_executable_path).RemoveExtension("exe")); |
---|
| 375 | #else |
---|
| 376 | result.Set(FilePath(g_executable_path)); |
---|
| 377 | #endif // GTEST_OS_WINDOWS |
---|
| 378 | |
---|
| 379 | return result.RemoveDirectoryName(); |
---|
| 380 | } |
---|
| 381 | |
---|
| 382 | // Functions for processing the gtest_output flag. |
---|
| 383 | |
---|
| 384 | // Returns the output format, or "" for normal printed output. |
---|
| 385 | String UnitTestOptions::GetOutputFormat() { |
---|
| 386 | const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); |
---|
| 387 | if (gtest_output_flag == NULL) return String(""); |
---|
| 388 | |
---|
| 389 | const char* const colon = strchr(gtest_output_flag, ':'); |
---|
| 390 | return (colon == NULL) ? |
---|
| 391 | String(gtest_output_flag) : |
---|
| 392 | String(gtest_output_flag, colon - gtest_output_flag); |
---|
| 393 | } |
---|
| 394 | |
---|
| 395 | // Returns the name of the requested output file, or the default if none |
---|
| 396 | // was explicitly specified. |
---|
| 397 | String UnitTestOptions::GetAbsolutePathToOutputFile() { |
---|
| 398 | const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); |
---|
| 399 | if (gtest_output_flag == NULL) |
---|
| 400 | return String(""); |
---|
| 401 | |
---|
| 402 | const char* const colon = strchr(gtest_output_flag, ':'); |
---|
| 403 | if (colon == NULL) |
---|
| 404 | return String(internal::FilePath::ConcatPaths( |
---|
| 405 | internal::FilePath( |
---|
| 406 | UnitTest::GetInstance()->original_working_dir()), |
---|
| 407 | internal::FilePath(kDefaultOutputFile)).ToString() ); |
---|
| 408 | |
---|
| 409 | internal::FilePath output_name(colon + 1); |
---|
| 410 | if (!output_name.IsAbsolutePath()) |
---|
| 411 | // TODO(wan@google.com): on Windows \some\path is not an absolute |
---|
| 412 | // path (as its meaning depends on the current drive), yet the |
---|
| 413 | // following logic for turning it into an absolute path is wrong. |
---|
| 414 | // Fix it. |
---|
| 415 | output_name = internal::FilePath::ConcatPaths( |
---|
| 416 | internal::FilePath(UnitTest::GetInstance()->original_working_dir()), |
---|
| 417 | internal::FilePath(colon + 1)); |
---|
| 418 | |
---|
| 419 | if (!output_name.IsDirectory()) |
---|
| 420 | return output_name.ToString(); |
---|
| 421 | |
---|
| 422 | internal::FilePath result(internal::FilePath::GenerateUniqueFileName( |
---|
| 423 | output_name, internal::GetCurrentExecutableName(), |
---|
| 424 | GetOutputFormat().c_str())); |
---|
| 425 | return result.ToString(); |
---|
| 426 | } |
---|
| 427 | |
---|
| 428 | // Returns true iff the wildcard pattern matches the string. The |
---|
| 429 | // first ':' or '\0' character in pattern marks the end of it. |
---|
| 430 | // |
---|
| 431 | // This recursive algorithm isn't very efficient, but is clear and |
---|
| 432 | // works well enough for matching test names, which are short. |
---|
| 433 | bool UnitTestOptions::PatternMatchesString(const char *pattern, |
---|
| 434 | const char *str) { |
---|
| 435 | switch (*pattern) { |
---|
| 436 | case '\0': |
---|
| 437 | case ':': // Either ':' or '\0' marks the end of the pattern. |
---|
| 438 | return *str == '\0'; |
---|
| 439 | case '?': // Matches any single character. |
---|
| 440 | return *str != '\0' && PatternMatchesString(pattern + 1, str + 1); |
---|
| 441 | case '*': // Matches any string (possibly empty) of characters. |
---|
| 442 | return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || |
---|
| 443 | PatternMatchesString(pattern + 1, str); |
---|
| 444 | default: // Non-special character. Matches itself. |
---|
| 445 | return *pattern == *str && |
---|
| 446 | PatternMatchesString(pattern + 1, str + 1); |
---|
| 447 | } |
---|
| 448 | } |
---|
| 449 | |
---|
| 450 | bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) { |
---|
| 451 | const char *cur_pattern = filter; |
---|
| 452 | for (;;) { |
---|
| 453 | if (PatternMatchesString(cur_pattern, name.c_str())) { |
---|
| 454 | return true; |
---|
| 455 | } |
---|
| 456 | |
---|
| 457 | // Finds the next pattern in the filter. |
---|
| 458 | cur_pattern = strchr(cur_pattern, ':'); |
---|
| 459 | |
---|
| 460 | // Returns if no more pattern can be found. |
---|
| 461 | if (cur_pattern == NULL) { |
---|
| 462 | return false; |
---|
| 463 | } |
---|
| 464 | |
---|
| 465 | // Skips the pattern separater (the ':' character). |
---|
| 466 | cur_pattern++; |
---|
| 467 | } |
---|
| 468 | } |
---|
| 469 | |
---|
| 470 | // TODO(keithray): move String function implementations to gtest-string.cc. |
---|
| 471 | |
---|
| 472 | // Returns true iff the user-specified filter matches the test case |
---|
| 473 | // name and the test name. |
---|
| 474 | bool UnitTestOptions::FilterMatchesTest(const String &test_case_name, |
---|
| 475 | const String &test_name) { |
---|
| 476 | const String& full_name = String::Format("%s.%s", |
---|
| 477 | test_case_name.c_str(), |
---|
| 478 | test_name.c_str()); |
---|
| 479 | |
---|
| 480 | // Split --gtest_filter at '-', if there is one, to separate into |
---|
| 481 | // positive filter and negative filter portions |
---|
| 482 | const char* const p = GTEST_FLAG(filter).c_str(); |
---|
| 483 | const char* const dash = strchr(p, '-'); |
---|
| 484 | String positive; |
---|
| 485 | String negative; |
---|
| 486 | if (dash == NULL) { |
---|
| 487 | positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter |
---|
| 488 | negative = String(""); |
---|
| 489 | } else { |
---|
| 490 | positive = String(p, dash - p); // Everything up to the dash |
---|
| 491 | negative = String(dash+1); // Everything after the dash |
---|
| 492 | if (positive.empty()) { |
---|
| 493 | // Treat '-test1' as the same as '*-test1' |
---|
| 494 | positive = kUniversalFilter; |
---|
| 495 | } |
---|
| 496 | } |
---|
| 497 | |
---|
| 498 | // A filter is a colon-separated list of patterns. It matches a |
---|
| 499 | // test if any pattern in it matches the test. |
---|
| 500 | return (MatchesFilter(full_name, positive.c_str()) && |
---|
| 501 | !MatchesFilter(full_name, negative.c_str())); |
---|
| 502 | } |
---|
| 503 | |
---|
| 504 | #if GTEST_HAS_SEH |
---|
| 505 | // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the |
---|
| 506 | // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. |
---|
| 507 | // This function is useful as an __except condition. |
---|
| 508 | int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { |
---|
| 509 | // Google Test should handle a SEH exception if: |
---|
| 510 | // 1. the user wants it to, AND |
---|
| 511 | // 2. this is not a breakpoint exception, AND |
---|
| 512 | // 3. this is not a C++ exception (VC++ implements them via SEH, |
---|
| 513 | // apparently). |
---|
| 514 | // |
---|
| 515 | // SEH exception code for C++ exceptions. |
---|
| 516 | // (see http://support.microsoft.com/kb/185294 for more information). |
---|
| 517 | const DWORD kCxxExceptionCode = 0xe06d7363; |
---|
| 518 | |
---|
| 519 | bool should_handle = true; |
---|
| 520 | |
---|
| 521 | if (!GTEST_FLAG(catch_exceptions)) |
---|
| 522 | should_handle = false; |
---|
| 523 | else if (exception_code == EXCEPTION_BREAKPOINT) |
---|
| 524 | should_handle = false; |
---|
| 525 | else if (exception_code == kCxxExceptionCode) |
---|
| 526 | should_handle = false; |
---|
| 527 | |
---|
| 528 | return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; |
---|
| 529 | } |
---|
| 530 | #endif // GTEST_HAS_SEH |
---|
| 531 | |
---|
| 532 | } // namespace internal |
---|
| 533 | |
---|
| 534 | // The c'tor sets this object as the test part result reporter used by |
---|
| 535 | // Google Test. The 'result' parameter specifies where to report the |
---|
| 536 | // results. Intercepts only failures from the current thread. |
---|
| 537 | ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( |
---|
| 538 | TestPartResultArray* result) |
---|
| 539 | : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), |
---|
| 540 | result_(result) { |
---|
| 541 | Init(); |
---|
| 542 | } |
---|
| 543 | |
---|
| 544 | // The c'tor sets this object as the test part result reporter used by |
---|
| 545 | // Google Test. The 'result' parameter specifies where to report the |
---|
| 546 | // results. |
---|
| 547 | ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( |
---|
| 548 | InterceptMode intercept_mode, TestPartResultArray* result) |
---|
| 549 | : intercept_mode_(intercept_mode), |
---|
| 550 | result_(result) { |
---|
| 551 | Init(); |
---|
| 552 | } |
---|
| 553 | |
---|
| 554 | void ScopedFakeTestPartResultReporter::Init() { |
---|
| 555 | internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); |
---|
| 556 | if (intercept_mode_ == INTERCEPT_ALL_THREADS) { |
---|
| 557 | old_reporter_ = impl->GetGlobalTestPartResultReporter(); |
---|
| 558 | impl->SetGlobalTestPartResultReporter(this); |
---|
| 559 | } else { |
---|
| 560 | old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); |
---|
| 561 | impl->SetTestPartResultReporterForCurrentThread(this); |
---|
| 562 | } |
---|
| 563 | } |
---|
| 564 | |
---|
| 565 | // The d'tor restores the test part result reporter used by Google Test |
---|
| 566 | // before. |
---|
| 567 | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { |
---|
| 568 | internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); |
---|
| 569 | if (intercept_mode_ == INTERCEPT_ALL_THREADS) { |
---|
| 570 | impl->SetGlobalTestPartResultReporter(old_reporter_); |
---|
| 571 | } else { |
---|
| 572 | impl->SetTestPartResultReporterForCurrentThread(old_reporter_); |
---|
| 573 | } |
---|
| 574 | } |
---|
| 575 | |
---|
| 576 | // Increments the test part result count and remembers the result. |
---|
| 577 | // This method is from the TestPartResultReporterInterface interface. |
---|
| 578 | void ScopedFakeTestPartResultReporter::ReportTestPartResult( |
---|
| 579 | const TestPartResult& result) { |
---|
| 580 | result_->Append(result); |
---|
| 581 | } |
---|
| 582 | |
---|
| 583 | namespace internal { |
---|
| 584 | |
---|
| 585 | // Returns the type ID of ::testing::Test. We should always call this |
---|
| 586 | // instead of GetTypeId< ::testing::Test>() to get the type ID of |
---|
| 587 | // testing::Test. This is to work around a suspected linker bug when |
---|
| 588 | // using Google Test as a framework on Mac OS X. The bug causes |
---|
| 589 | // GetTypeId< ::testing::Test>() to return different values depending |
---|
| 590 | // on whether the call is from the Google Test framework itself or |
---|
| 591 | // from user test code. GetTestTypeId() is guaranteed to always |
---|
| 592 | // return the same value, as it always calls GetTypeId<>() from the |
---|
| 593 | // gtest.cc, which is within the Google Test framework. |
---|
| 594 | TypeId GetTestTypeId() { |
---|
| 595 | return GetTypeId<Test>(); |
---|
| 596 | } |
---|
| 597 | |
---|
| 598 | // The value of GetTestTypeId() as seen from within the Google Test |
---|
| 599 | // library. This is solely for testing GetTestTypeId(). |
---|
| 600 | extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); |
---|
| 601 | |
---|
| 602 | // This predicate-formatter checks that 'results' contains a test part |
---|
| 603 | // failure of the given type and that the failure message contains the |
---|
| 604 | // given substring. |
---|
| 605 | AssertionResult HasOneFailure(const char* /* results_expr */, |
---|
| 606 | const char* /* type_expr */, |
---|
| 607 | const char* /* substr_expr */, |
---|
| 608 | const TestPartResultArray& results, |
---|
| 609 | TestPartResult::Type type, |
---|
| 610 | const string& substr) { |
---|
| 611 | const String expected(type == TestPartResult::kFatalFailure ? |
---|
| 612 | "1 fatal failure" : |
---|
| 613 | "1 non-fatal failure"); |
---|
| 614 | Message msg; |
---|
| 615 | if (results.size() != 1) { |
---|
| 616 | msg << "Expected: " << expected << "\n" |
---|
| 617 | << " Actual: " << results.size() << " failures"; |
---|
| 618 | for (int i = 0; i < results.size(); i++) { |
---|
| 619 | msg << "\n" << results.GetTestPartResult(i); |
---|
| 620 | } |
---|
| 621 | return AssertionFailure() << msg; |
---|
| 622 | } |
---|
| 623 | |
---|
| 624 | const TestPartResult& r = results.GetTestPartResult(0); |
---|
| 625 | if (r.type() != type) { |
---|
| 626 | return AssertionFailure() << "Expected: " << expected << "\n" |
---|
| 627 | << " Actual:\n" |
---|
| 628 | << r; |
---|
| 629 | } |
---|
| 630 | |
---|
| 631 | if (strstr(r.message(), substr.c_str()) == NULL) { |
---|
| 632 | return AssertionFailure() << "Expected: " << expected << " containing \"" |
---|
| 633 | << substr << "\"\n" |
---|
| 634 | << " Actual:\n" |
---|
| 635 | << r; |
---|
| 636 | } |
---|
| 637 | |
---|
| 638 | return AssertionSuccess(); |
---|
| 639 | } |
---|
| 640 | |
---|
| 641 | // The constructor of SingleFailureChecker remembers where to look up |
---|
| 642 | // test part results, what type of failure we expect, and what |
---|
| 643 | // substring the failure message should contain. |
---|
| 644 | SingleFailureChecker:: SingleFailureChecker( |
---|
| 645 | const TestPartResultArray* results, |
---|
| 646 | TestPartResult::Type type, |
---|
| 647 | const string& substr) |
---|
| 648 | : results_(results), |
---|
| 649 | type_(type), |
---|
| 650 | substr_(substr) {} |
---|
| 651 | |
---|
| 652 | // The destructor of SingleFailureChecker verifies that the given |
---|
| 653 | // TestPartResultArray contains exactly one failure that has the given |
---|
| 654 | // type and contains the given substring. If that's not the case, a |
---|
| 655 | // non-fatal failure will be generated. |
---|
| 656 | SingleFailureChecker::~SingleFailureChecker() { |
---|
| 657 | EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); |
---|
| 658 | } |
---|
| 659 | |
---|
| 660 | DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( |
---|
| 661 | UnitTestImpl* unit_test) : unit_test_(unit_test) {} |
---|
| 662 | |
---|
| 663 | void DefaultGlobalTestPartResultReporter::ReportTestPartResult( |
---|
| 664 | const TestPartResult& result) { |
---|
| 665 | unit_test_->current_test_result()->AddTestPartResult(result); |
---|
| 666 | unit_test_->listeners()->repeater()->OnTestPartResult(result); |
---|
| 667 | } |
---|
| 668 | |
---|
| 669 | DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( |
---|
| 670 | UnitTestImpl* unit_test) : unit_test_(unit_test) {} |
---|
| 671 | |
---|
| 672 | void DefaultPerThreadTestPartResultReporter::ReportTestPartResult( |
---|
| 673 | const TestPartResult& result) { |
---|
| 674 | unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); |
---|
| 675 | } |
---|
| 676 | |
---|
| 677 | // Returns the global test part result reporter. |
---|
| 678 | TestPartResultReporterInterface* |
---|
| 679 | UnitTestImpl::GetGlobalTestPartResultReporter() { |
---|
| 680 | internal::MutexLock lock(&global_test_part_result_reporter_mutex_); |
---|
| 681 | return global_test_part_result_repoter_; |
---|
| 682 | } |
---|
| 683 | |
---|
| 684 | // Sets the global test part result reporter. |
---|
| 685 | void UnitTestImpl::SetGlobalTestPartResultReporter( |
---|
| 686 | TestPartResultReporterInterface* reporter) { |
---|
| 687 | internal::MutexLock lock(&global_test_part_result_reporter_mutex_); |
---|
| 688 | global_test_part_result_repoter_ = reporter; |
---|
| 689 | } |
---|
| 690 | |
---|
| 691 | // Returns the test part result reporter for the current thread. |
---|
| 692 | TestPartResultReporterInterface* |
---|
| 693 | UnitTestImpl::GetTestPartResultReporterForCurrentThread() { |
---|
| 694 | return per_thread_test_part_result_reporter_.get(); |
---|
| 695 | } |
---|
| 696 | |
---|
| 697 | // Sets the test part result reporter for the current thread. |
---|
| 698 | void UnitTestImpl::SetTestPartResultReporterForCurrentThread( |
---|
| 699 | TestPartResultReporterInterface* reporter) { |
---|
| 700 | per_thread_test_part_result_reporter_.set(reporter); |
---|
| 701 | } |
---|
| 702 | |
---|
| 703 | // Gets the number of successful test cases. |
---|
| 704 | int UnitTestImpl::successful_test_case_count() const { |
---|
| 705 | return CountIf(test_cases_, TestCasePassed); |
---|
| 706 | } |
---|
| 707 | |
---|
| 708 | // Gets the number of failed test cases. |
---|
| 709 | int UnitTestImpl::failed_test_case_count() const { |
---|
| 710 | return CountIf(test_cases_, TestCaseFailed); |
---|
| 711 | } |
---|
| 712 | |
---|
| 713 | // Gets the number of all test cases. |
---|
| 714 | int UnitTestImpl::total_test_case_count() const { |
---|
| 715 | return static_cast<int>(test_cases_.size()); |
---|
| 716 | } |
---|
| 717 | |
---|
| 718 | // Gets the number of all test cases that contain at least one test |
---|
| 719 | // that should run. |
---|
| 720 | int UnitTestImpl::test_case_to_run_count() const { |
---|
| 721 | return CountIf(test_cases_, ShouldRunTestCase); |
---|
| 722 | } |
---|
| 723 | |
---|
| 724 | // Gets the number of successful tests. |
---|
| 725 | int UnitTestImpl::successful_test_count() const { |
---|
| 726 | return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); |
---|
| 727 | } |
---|
| 728 | |
---|
| 729 | // Gets the number of failed tests. |
---|
| 730 | int UnitTestImpl::failed_test_count() const { |
---|
| 731 | return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); |
---|
| 732 | } |
---|
| 733 | |
---|
| 734 | // Gets the number of disabled tests. |
---|
| 735 | int UnitTestImpl::disabled_test_count() const { |
---|
| 736 | return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); |
---|
| 737 | } |
---|
| 738 | |
---|
| 739 | // Gets the number of all tests. |
---|
| 740 | int UnitTestImpl::total_test_count() const { |
---|
| 741 | return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); |
---|
| 742 | } |
---|
| 743 | |
---|
| 744 | // Gets the number of tests that should run. |
---|
| 745 | int UnitTestImpl::test_to_run_count() const { |
---|
| 746 | return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); |
---|
| 747 | } |
---|
| 748 | |
---|
| 749 | // Returns the current OS stack trace as a String. |
---|
| 750 | // |
---|
| 751 | // The maximum number of stack frames to be included is specified by |
---|
| 752 | // the gtest_stack_trace_depth flag. The skip_count parameter |
---|
| 753 | // specifies the number of top frames to be skipped, which doesn't |
---|
| 754 | // count against the number of frames to be included. |
---|
| 755 | // |
---|
| 756 | // For example, if Foo() calls Bar(), which in turn calls |
---|
| 757 | // CurrentOsStackTraceExceptTop(1), Foo() will be included in the |
---|
| 758 | // trace but Bar() and CurrentOsStackTraceExceptTop() won't. |
---|
| 759 | String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { |
---|
| 760 | (void)skip_count; |
---|
| 761 | return String(""); |
---|
| 762 | } |
---|
| 763 | |
---|
| 764 | // Returns the current time in milliseconds. |
---|
| 765 | TimeInMillis GetTimeInMillis() { |
---|
| 766 | #if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) |
---|
| 767 | // Difference between 1970-01-01 and 1601-01-01 in milliseconds. |
---|
| 768 | // http://analogous.blogspot.com/2005/04/epoch.html |
---|
| 769 | const TimeInMillis kJavaEpochToWinFileTimeDelta = |
---|
| 770 | static_cast<TimeInMillis>(116444736UL) * 100000UL; |
---|
| 771 | const DWORD kTenthMicrosInMilliSecond = 10000; |
---|
| 772 | |
---|
| 773 | SYSTEMTIME now_systime; |
---|
| 774 | FILETIME now_filetime; |
---|
| 775 | ULARGE_INTEGER now_int64; |
---|
| 776 | // TODO(kenton@google.com): Shouldn't this just use |
---|
| 777 | // GetSystemTimeAsFileTime()? |
---|
| 778 | GetSystemTime(&now_systime); |
---|
| 779 | if (SystemTimeToFileTime(&now_systime, &now_filetime)) { |
---|
| 780 | now_int64.LowPart = now_filetime.dwLowDateTime; |
---|
| 781 | now_int64.HighPart = now_filetime.dwHighDateTime; |
---|
| 782 | now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - |
---|
| 783 | kJavaEpochToWinFileTimeDelta; |
---|
| 784 | return now_int64.QuadPart; |
---|
| 785 | } |
---|
| 786 | return 0; |
---|
| 787 | #elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ |
---|
| 788 | __timeb64 now; |
---|
| 789 | |
---|
| 790 | # ifdef _MSC_VER |
---|
| 791 | |
---|
| 792 | // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 |
---|
| 793 | // (deprecated function) there. |
---|
| 794 | // TODO(kenton@google.com): Use GetTickCount()? Or use |
---|
| 795 | // SystemTimeToFileTime() |
---|
| 796 | # pragma warning(push) // Saves the current warning state. |
---|
| 797 | # pragma warning(disable:4996) // Temporarily disables warning 4996. |
---|
| 798 | _ftime64(&now); |
---|
| 799 | # pragma warning(pop) // Restores the warning state. |
---|
| 800 | # else |
---|
| 801 | |
---|
| 802 | _ftime64(&now); |
---|
| 803 | |
---|
| 804 | # endif // _MSC_VER |
---|
| 805 | |
---|
| 806 | return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; |
---|
| 807 | #elif GTEST_HAS_GETTIMEOFDAY_ |
---|
| 808 | struct timeval now; |
---|
| 809 | gettimeofday(&now, NULL); |
---|
| 810 | return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000; |
---|
| 811 | #else |
---|
| 812 | # error "Don't know how to get the current time on your system." |
---|
| 813 | #endif |
---|
| 814 | } |
---|
| 815 | |
---|
| 816 | // Utilities |
---|
| 817 | |
---|
| 818 | // class String |
---|
| 819 | |
---|
| 820 | // Returns the input enclosed in double quotes if it's not NULL; |
---|
| 821 | // otherwise returns "(null)". For example, "\"Hello\"" is returned |
---|
| 822 | // for input "Hello". |
---|
| 823 | // |
---|
| 824 | // This is useful for printing a C string in the syntax of a literal. |
---|
| 825 | // |
---|
| 826 | // Known issue: escape sequences are not handled yet. |
---|
| 827 | String String::ShowCStringQuoted(const char* c_str) { |
---|
| 828 | return c_str ? String::Format("\"%s\"", c_str) : String("(null)"); |
---|
| 829 | } |
---|
| 830 | |
---|
| 831 | // Copies at most length characters from str into a newly-allocated |
---|
| 832 | // piece of memory of size length+1. The memory is allocated with new[]. |
---|
| 833 | // A terminating null byte is written to the memory, and a pointer to it |
---|
| 834 | // is returned. If str is NULL, NULL is returned. |
---|
| 835 | static char* CloneString(const char* str, size_t length) { |
---|
| 836 | if (str == NULL) { |
---|
| 837 | return NULL; |
---|
| 838 | } else { |
---|
| 839 | char* const clone = new char[length + 1]; |
---|
| 840 | posix::StrNCpy(clone, str, length); |
---|
| 841 | clone[length] = '\0'; |
---|
| 842 | return clone; |
---|
| 843 | } |
---|
| 844 | } |
---|
| 845 | |
---|
| 846 | // Clones a 0-terminated C string, allocating memory using new. The |
---|
| 847 | // caller is responsible for deleting[] the return value. Returns the |
---|
| 848 | // cloned string, or NULL if the input is NULL. |
---|
| 849 | const char * String::CloneCString(const char* c_str) { |
---|
| 850 | return (c_str == NULL) ? |
---|
| 851 | NULL : CloneString(c_str, strlen(c_str)); |
---|
| 852 | } |
---|
| 853 | |
---|
| 854 | #if GTEST_OS_WINDOWS_MOBILE |
---|
| 855 | // Creates a UTF-16 wide string from the given ANSI string, allocating |
---|
| 856 | // memory using new. The caller is responsible for deleting the return |
---|
| 857 | // value using delete[]. Returns the wide string, or NULL if the |
---|
| 858 | // input is NULL. |
---|
| 859 | LPCWSTR String::AnsiToUtf16(const char* ansi) { |
---|
| 860 | if (!ansi) return NULL; |
---|
| 861 | const int length = strlen(ansi); |
---|
| 862 | const int unicode_length = |
---|
| 863 | MultiByteToWideChar(CP_ACP, 0, ansi, length, |
---|
| 864 | NULL, 0); |
---|
| 865 | WCHAR* unicode = new WCHAR[unicode_length + 1]; |
---|
| 866 | MultiByteToWideChar(CP_ACP, 0, ansi, length, |
---|
| 867 | unicode, unicode_length); |
---|
| 868 | unicode[unicode_length] = 0; |
---|
| 869 | return unicode; |
---|
| 870 | } |
---|
| 871 | |
---|
| 872 | // Creates an ANSI string from the given wide string, allocating |
---|
| 873 | // memory using new. The caller is responsible for deleting the return |
---|
| 874 | // value using delete[]. Returns the ANSI string, or NULL if the |
---|
| 875 | // input is NULL. |
---|
| 876 | const char* String::Utf16ToAnsi(LPCWSTR utf16_str) { |
---|
| 877 | if (!utf16_str) return NULL; |
---|
| 878 | const int ansi_length = |
---|
| 879 | WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, |
---|
| 880 | NULL, 0, NULL, NULL); |
---|
| 881 | char* ansi = new char[ansi_length + 1]; |
---|
| 882 | WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, |
---|
| 883 | ansi, ansi_length, NULL, NULL); |
---|
| 884 | ansi[ansi_length] = 0; |
---|
| 885 | return ansi; |
---|
| 886 | } |
---|
| 887 | |
---|
| 888 | #endif // GTEST_OS_WINDOWS_MOBILE |
---|
| 889 | |
---|
| 890 | // Compares two C strings. Returns true iff they have the same content. |
---|
| 891 | // |
---|
| 892 | // Unlike strcmp(), this function can handle NULL argument(s). A NULL |
---|
| 893 | // C string is considered different to any non-NULL C string, |
---|
| 894 | // including the empty string. |
---|
| 895 | bool String::CStringEquals(const char * lhs, const char * rhs) { |
---|
| 896 | if ( lhs == NULL ) return rhs == NULL; |
---|
| 897 | |
---|
| 898 | if ( rhs == NULL ) return false; |
---|
| 899 | |
---|
| 900 | return strcmp(lhs, rhs) == 0; |
---|
| 901 | } |
---|
| 902 | |
---|
| 903 | #if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING |
---|
| 904 | |
---|
| 905 | // Converts an array of wide chars to a narrow string using the UTF-8 |
---|
| 906 | // encoding, and streams the result to the given Message object. |
---|
| 907 | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, |
---|
| 908 | Message* msg) { |
---|
| 909 | // TODO(wan): consider allowing a testing::String object to |
---|
| 910 | // contain '\0'. This will make it behave more like std::string, |
---|
| 911 | // and will allow ToUtf8String() to return the correct encoding |
---|
| 912 | // for '\0' s.t. we can get rid of the conditional here (and in |
---|
| 913 | // several other places). |
---|
| 914 | for (size_t i = 0; i != length; ) { // NOLINT |
---|
| 915 | if (wstr[i] != L'\0') { |
---|
| 916 | *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i)); |
---|
| 917 | while (i != length && wstr[i] != L'\0') |
---|
| 918 | i++; |
---|
| 919 | } else { |
---|
| 920 | *msg << '\0'; |
---|
| 921 | i++; |
---|
| 922 | } |
---|
| 923 | } |
---|
| 924 | } |
---|
| 925 | |
---|
| 926 | #endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING |
---|
| 927 | |
---|
| 928 | } // namespace internal |
---|
| 929 | |
---|
| 930 | #if GTEST_HAS_STD_WSTRING |
---|
| 931 | // Converts the given wide string to a narrow string using the UTF-8 |
---|
| 932 | // encoding, and streams the result to this Message object. |
---|
| 933 | Message& Message::operator <<(const ::std::wstring& wstr) { |
---|
| 934 | internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); |
---|
| 935 | return *this; |
---|
| 936 | } |
---|
| 937 | #endif // GTEST_HAS_STD_WSTRING |
---|
| 938 | |
---|
| 939 | #if GTEST_HAS_GLOBAL_WSTRING |
---|
| 940 | // Converts the given wide string to a narrow string using the UTF-8 |
---|
| 941 | // encoding, and streams the result to this Message object. |
---|
| 942 | Message& Message::operator <<(const ::wstring& wstr) { |
---|
| 943 | internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); |
---|
| 944 | return *this; |
---|
| 945 | } |
---|
| 946 | #endif // GTEST_HAS_GLOBAL_WSTRING |
---|
| 947 | |
---|
| 948 | // AssertionResult constructors. |
---|
| 949 | // Used in EXPECT_TRUE/FALSE(assertion_result). |
---|
| 950 | AssertionResult::AssertionResult(const AssertionResult& other) |
---|
| 951 | : success_(other.success_), |
---|
| 952 | message_(other.message_.get() != NULL ? |
---|
| 953 | new ::std::string(*other.message_) : |
---|
| 954 | static_cast< ::std::string*>(NULL)) { |
---|
| 955 | } |
---|
| 956 | |
---|
| 957 | // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. |
---|
| 958 | AssertionResult AssertionResult::operator!() const { |
---|
| 959 | AssertionResult negation(!success_); |
---|
| 960 | if (message_.get() != NULL) |
---|
| 961 | negation << *message_; |
---|
| 962 | return negation; |
---|
| 963 | } |
---|
| 964 | |
---|
| 965 | // Makes a successful assertion result. |
---|
| 966 | AssertionResult AssertionSuccess() { |
---|
| 967 | return AssertionResult(true); |
---|
| 968 | } |
---|
| 969 | |
---|
| 970 | // Makes a failed assertion result. |
---|
| 971 | AssertionResult AssertionFailure() { |
---|
| 972 | return AssertionResult(false); |
---|
| 973 | } |
---|
| 974 | |
---|
| 975 | // Makes a failed assertion result with the given failure message. |
---|
| 976 | // Deprecated; use AssertionFailure() << message. |
---|
| 977 | AssertionResult AssertionFailure(const Message& message) { |
---|
| 978 | return AssertionFailure() << message; |
---|
| 979 | } |
---|
| 980 | |
---|
| 981 | namespace internal { |
---|
| 982 | |
---|
| 983 | // Constructs and returns the message for an equality assertion |
---|
| 984 | // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. |
---|
| 985 | // |
---|
| 986 | // The first four parameters are the expressions used in the assertion |
---|
| 987 | // and their values, as strings. For example, for ASSERT_EQ(foo, bar) |
---|
| 988 | // where foo is 5 and bar is 6, we have: |
---|
| 989 | // |
---|
| 990 | // expected_expression: "foo" |
---|
| 991 | // actual_expression: "bar" |
---|
| 992 | // expected_value: "5" |
---|
| 993 | // actual_value: "6" |
---|
| 994 | // |
---|
| 995 | // The ignoring_case parameter is true iff the assertion is a |
---|
| 996 | // *_STRCASEEQ*. When it's true, the string " (ignoring case)" will |
---|
| 997 | // be inserted into the message. |
---|
| 998 | AssertionResult EqFailure(const char* expected_expression, |
---|
| 999 | const char* actual_expression, |
---|
| 1000 | const String& expected_value, |
---|
| 1001 | const String& actual_value, |
---|
| 1002 | bool ignoring_case) { |
---|
| 1003 | Message msg; |
---|
| 1004 | msg << "Value of: " << actual_expression; |
---|
| 1005 | if (actual_value != actual_expression) { |
---|
| 1006 | msg << "\n Actual: " << actual_value; |
---|
| 1007 | } |
---|
| 1008 | |
---|
| 1009 | msg << "\nExpected: " << expected_expression; |
---|
| 1010 | if (ignoring_case) { |
---|
| 1011 | msg << " (ignoring case)"; |
---|
| 1012 | } |
---|
| 1013 | if (expected_value != expected_expression) { |
---|
| 1014 | msg << "\nWhich is: " << expected_value; |
---|
| 1015 | } |
---|
| 1016 | |
---|
| 1017 | return AssertionFailure() << msg; |
---|
| 1018 | } |
---|
| 1019 | |
---|
| 1020 | // Constructs a failure message for Boolean assertions such as EXPECT_TRUE. |
---|
| 1021 | String GetBoolAssertionFailureMessage(const AssertionResult& assertion_result, |
---|
| 1022 | const char* expression_text, |
---|
| 1023 | const char* actual_predicate_value, |
---|
| 1024 | const char* expected_predicate_value) { |
---|
| 1025 | const char* actual_message = assertion_result.message(); |
---|
| 1026 | Message msg; |
---|
| 1027 | msg << "Value of: " << expression_text |
---|
| 1028 | << "\n Actual: " << actual_predicate_value; |
---|
| 1029 | if (actual_message[0] != '\0') |
---|
| 1030 | msg << " (" << actual_message << ")"; |
---|
| 1031 | msg << "\nExpected: " << expected_predicate_value; |
---|
| 1032 | return msg.GetString(); |
---|
| 1033 | } |
---|
| 1034 | |
---|
| 1035 | // Helper function for implementing ASSERT_NEAR. |
---|
| 1036 | AssertionResult DoubleNearPredFormat(const char* expr1, |
---|
| 1037 | const char* expr2, |
---|
| 1038 | const char* abs_error_expr, |
---|
| 1039 | double val1, |
---|
| 1040 | double val2, |
---|
| 1041 | double abs_error) { |
---|
| 1042 | const double diff = fabs(val1 - val2); |
---|
| 1043 | if (diff <= abs_error) return AssertionSuccess(); |
---|
| 1044 | |
---|
| 1045 | // TODO(wan): do not print the value of an expression if it's |
---|
| 1046 | // already a literal. |
---|
| 1047 | return AssertionFailure() |
---|
| 1048 | << "The difference between " << expr1 << " and " << expr2 |
---|
| 1049 | << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" |
---|
| 1050 | << expr1 << " evaluates to " << val1 << ",\n" |
---|
| 1051 | << expr2 << " evaluates to " << val2 << ", and\n" |
---|
| 1052 | << abs_error_expr << " evaluates to " << abs_error << "."; |
---|
| 1053 | } |
---|
| 1054 | |
---|
| 1055 | |
---|
| 1056 | // Helper template for implementing FloatLE() and DoubleLE(). |
---|
| 1057 | template <typename RawType> |
---|
| 1058 | AssertionResult FloatingPointLE(const char* expr1, |
---|
| 1059 | const char* expr2, |
---|
| 1060 | RawType val1, |
---|
| 1061 | RawType val2) { |
---|
| 1062 | // Returns success if val1 is less than val2, |
---|
| 1063 | if (val1 < val2) { |
---|
| 1064 | return AssertionSuccess(); |
---|
| 1065 | } |
---|
| 1066 | |
---|
| 1067 | // or if val1 is almost equal to val2. |
---|
| 1068 | const FloatingPoint<RawType> lhs(val1), rhs(val2); |
---|
| 1069 | if (lhs.AlmostEquals(rhs)) { |
---|
| 1070 | return AssertionSuccess(); |
---|
| 1071 | } |
---|
| 1072 | |
---|
| 1073 | // Note that the above two checks will both fail if either val1 or |
---|
| 1074 | // val2 is NaN, as the IEEE floating-point standard requires that |
---|
| 1075 | // any predicate involving a NaN must return false. |
---|
| 1076 | |
---|
| 1077 | ::std::stringstream val1_ss; |
---|
| 1078 | val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) |
---|
| 1079 | << val1; |
---|
| 1080 | |
---|
| 1081 | ::std::stringstream val2_ss; |
---|
| 1082 | val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) |
---|
| 1083 | << val2; |
---|
| 1084 | |
---|
| 1085 | return AssertionFailure() |
---|
| 1086 | << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" |
---|
| 1087 | << " Actual: " << StringStreamToString(&val1_ss) << " vs " |
---|
| 1088 | << StringStreamToString(&val2_ss); |
---|
| 1089 | } |
---|
| 1090 | |
---|
| 1091 | } // namespace internal |
---|
| 1092 | |
---|
| 1093 | // Asserts that val1 is less than, or almost equal to, val2. Fails |
---|
| 1094 | // otherwise. In particular, it fails if either val1 or val2 is NaN. |
---|
| 1095 | AssertionResult FloatLE(const char* expr1, const char* expr2, |
---|
| 1096 | float val1, float val2) { |
---|
| 1097 | return internal::FloatingPointLE<float>(expr1, expr2, val1, val2); |
---|
| 1098 | } |
---|
| 1099 | |
---|
| 1100 | // Asserts that val1 is less than, or almost equal to, val2. Fails |
---|
| 1101 | // otherwise. In particular, it fails if either val1 or val2 is NaN. |
---|
| 1102 | AssertionResult DoubleLE(const char* expr1, const char* expr2, |
---|
| 1103 | double val1, double val2) { |
---|
| 1104 | return internal::FloatingPointLE<double>(expr1, expr2, val1, val2); |
---|
| 1105 | } |
---|
| 1106 | |
---|
| 1107 | namespace internal { |
---|
| 1108 | |
---|
| 1109 | // The helper function for {ASSERT|EXPECT}_EQ with int or enum |
---|
| 1110 | // arguments. |
---|
| 1111 | AssertionResult CmpHelperEQ(const char* expected_expression, |
---|
| 1112 | const char* actual_expression, |
---|
| 1113 | BiggestInt expected, |
---|
| 1114 | BiggestInt actual) { |
---|
| 1115 | if (expected == actual) { |
---|
| 1116 | return AssertionSuccess(); |
---|
| 1117 | } |
---|
| 1118 | |
---|
| 1119 | return EqFailure(expected_expression, |
---|
| 1120 | actual_expression, |
---|
| 1121 | FormatForComparisonFailureMessage(expected, actual), |
---|
| 1122 | FormatForComparisonFailureMessage(actual, expected), |
---|
| 1123 | false); |
---|
| 1124 | } |
---|
| 1125 | |
---|
| 1126 | // A macro for implementing the helper functions needed to implement |
---|
| 1127 | // ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here |
---|
| 1128 | // just to avoid copy-and-paste of similar code. |
---|
| 1129 | #define GTEST_IMPL_CMP_HELPER_(op_name, op)\ |
---|
| 1130 | AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ |
---|
| 1131 | BiggestInt val1, BiggestInt val2) {\ |
---|
| 1132 | if (val1 op val2) {\ |
---|
| 1133 | return AssertionSuccess();\ |
---|
| 1134 | } else {\ |
---|
| 1135 | return AssertionFailure() \ |
---|
| 1136 | << "Expected: (" << expr1 << ") " #op " (" << expr2\ |
---|
| 1137 | << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ |
---|
| 1138 | << " vs " << FormatForComparisonFailureMessage(val2, val1);\ |
---|
| 1139 | }\ |
---|
| 1140 | } |
---|
| 1141 | |
---|
| 1142 | // Implements the helper function for {ASSERT|EXPECT}_NE with int or |
---|
| 1143 | // enum arguments. |
---|
| 1144 | GTEST_IMPL_CMP_HELPER_(NE, !=) |
---|
| 1145 | // Implements the helper function for {ASSERT|EXPECT}_LE with int or |
---|
| 1146 | // enum arguments. |
---|
| 1147 | GTEST_IMPL_CMP_HELPER_(LE, <=) |
---|
| 1148 | // Implements the helper function for {ASSERT|EXPECT}_LT with int or |
---|
| 1149 | // enum arguments. |
---|
| 1150 | GTEST_IMPL_CMP_HELPER_(LT, < ) |
---|
| 1151 | // Implements the helper function for {ASSERT|EXPECT}_GE with int or |
---|
| 1152 | // enum arguments. |
---|
| 1153 | GTEST_IMPL_CMP_HELPER_(GE, >=) |
---|
| 1154 | // Implements the helper function for {ASSERT|EXPECT}_GT with int or |
---|
| 1155 | // enum arguments. |
---|
| 1156 | GTEST_IMPL_CMP_HELPER_(GT, > ) |
---|
| 1157 | |
---|
| 1158 | #undef GTEST_IMPL_CMP_HELPER_ |
---|
| 1159 | |
---|
| 1160 | // The helper function for {ASSERT|EXPECT}_STREQ. |
---|
| 1161 | AssertionResult CmpHelperSTREQ(const char* expected_expression, |
---|
| 1162 | const char* actual_expression, |
---|
| 1163 | const char* expected, |
---|
| 1164 | const char* actual) { |
---|
| 1165 | if (String::CStringEquals(expected, actual)) { |
---|
| 1166 | return AssertionSuccess(); |
---|
| 1167 | } |
---|
| 1168 | |
---|
| 1169 | return EqFailure(expected_expression, |
---|
| 1170 | actual_expression, |
---|
| 1171 | String::ShowCStringQuoted(expected), |
---|
| 1172 | String::ShowCStringQuoted(actual), |
---|
| 1173 | false); |
---|
| 1174 | } |
---|
| 1175 | |
---|
| 1176 | // The helper function for {ASSERT|EXPECT}_STRCASEEQ. |
---|
| 1177 | AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, |
---|
| 1178 | const char* actual_expression, |
---|
| 1179 | const char* expected, |
---|
| 1180 | const char* actual) { |
---|
| 1181 | if (String::CaseInsensitiveCStringEquals(expected, actual)) { |
---|
| 1182 | return AssertionSuccess(); |
---|
| 1183 | } |
---|
| 1184 | |
---|
| 1185 | return EqFailure(expected_expression, |
---|
| 1186 | actual_expression, |
---|
| 1187 | String::ShowCStringQuoted(expected), |
---|
| 1188 | String::ShowCStringQuoted(actual), |
---|
| 1189 | true); |
---|
| 1190 | } |
---|
| 1191 | |
---|
| 1192 | // The helper function for {ASSERT|EXPECT}_STRNE. |
---|
| 1193 | AssertionResult CmpHelperSTRNE(const char* s1_expression, |
---|
| 1194 | const char* s2_expression, |
---|
| 1195 | const char* s1, |
---|
| 1196 | const char* s2) { |
---|
| 1197 | if (!String::CStringEquals(s1, s2)) { |
---|
| 1198 | return AssertionSuccess(); |
---|
| 1199 | } else { |
---|
| 1200 | return AssertionFailure() << "Expected: (" << s1_expression << ") != (" |
---|
| 1201 | << s2_expression << "), actual: \"" |
---|
| 1202 | << s1 << "\" vs \"" << s2 << "\""; |
---|
| 1203 | } |
---|
| 1204 | } |
---|
| 1205 | |
---|
| 1206 | // The helper function for {ASSERT|EXPECT}_STRCASENE. |
---|
| 1207 | AssertionResult CmpHelperSTRCASENE(const char* s1_expression, |
---|
| 1208 | const char* s2_expression, |
---|
| 1209 | const char* s1, |
---|
| 1210 | const char* s2) { |
---|
| 1211 | if (!String::CaseInsensitiveCStringEquals(s1, s2)) { |
---|
| 1212 | return AssertionSuccess(); |
---|
| 1213 | } else { |
---|
| 1214 | return AssertionFailure() |
---|
| 1215 | << "Expected: (" << s1_expression << ") != (" |
---|
| 1216 | << s2_expression << ") (ignoring case), actual: \"" |
---|
| 1217 | << s1 << "\" vs \"" << s2 << "\""; |
---|
| 1218 | } |
---|
| 1219 | } |
---|
| 1220 | |
---|
| 1221 | } // namespace internal |
---|
| 1222 | |
---|
| 1223 | namespace { |
---|
| 1224 | |
---|
| 1225 | // Helper functions for implementing IsSubString() and IsNotSubstring(). |
---|
| 1226 | |
---|
| 1227 | // This group of overloaded functions return true iff needle is a |
---|
| 1228 | // substring of haystack. NULL is considered a substring of itself |
---|
| 1229 | // only. |
---|
| 1230 | |
---|
| 1231 | bool IsSubstringPred(const char* needle, const char* haystack) { |
---|
| 1232 | if (needle == NULL || haystack == NULL) |
---|
| 1233 | return needle == haystack; |
---|
| 1234 | |
---|
| 1235 | return strstr(haystack, needle) != NULL; |
---|
| 1236 | } |
---|
| 1237 | |
---|
| 1238 | bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { |
---|
| 1239 | if (needle == NULL || haystack == NULL) |
---|
| 1240 | return needle == haystack; |
---|
| 1241 | |
---|
| 1242 | return wcsstr(haystack, needle) != NULL; |
---|
| 1243 | } |
---|
| 1244 | |
---|
| 1245 | // StringType here can be either ::std::string or ::std::wstring. |
---|
| 1246 | template <typename StringType> |
---|
| 1247 | bool IsSubstringPred(const StringType& needle, |
---|
| 1248 | const StringType& haystack) { |
---|
| 1249 | return haystack.find(needle) != StringType::npos; |
---|
| 1250 | } |
---|
| 1251 | |
---|
| 1252 | // This function implements either IsSubstring() or IsNotSubstring(), |
---|
| 1253 | // depending on the value of the expected_to_be_substring parameter. |
---|
| 1254 | // StringType here can be const char*, const wchar_t*, ::std::string, |
---|
| 1255 | // or ::std::wstring. |
---|
| 1256 | template <typename StringType> |
---|
| 1257 | AssertionResult IsSubstringImpl( |
---|
| 1258 | bool expected_to_be_substring, |
---|
| 1259 | const char* needle_expr, const char* haystack_expr, |
---|
| 1260 | const StringType& needle, const StringType& haystack) { |
---|
| 1261 | if (IsSubstringPred(needle, haystack) == expected_to_be_substring) |
---|
| 1262 | return AssertionSuccess(); |
---|
| 1263 | |
---|
| 1264 | const bool is_wide_string = sizeof(needle[0]) > 1; |
---|
| 1265 | const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; |
---|
| 1266 | return AssertionFailure() |
---|
| 1267 | << "Value of: " << needle_expr << "\n" |
---|
| 1268 | << " Actual: " << begin_string_quote << needle << "\"\n" |
---|
| 1269 | << "Expected: " << (expected_to_be_substring ? "" : "not ") |
---|
| 1270 | << "a substring of " << haystack_expr << "\n" |
---|
| 1271 | << "Which is: " << begin_string_quote << haystack << "\""; |
---|
| 1272 | } |
---|
| 1273 | |
---|
| 1274 | } // namespace |
---|
| 1275 | |
---|
| 1276 | // IsSubstring() and IsNotSubstring() check whether needle is a |
---|
| 1277 | // substring of haystack (NULL is considered a substring of itself |
---|
| 1278 | // only), and return an appropriate error message when they fail. |
---|
| 1279 | |
---|
| 1280 | AssertionResult IsSubstring( |
---|
| 1281 | const char* needle_expr, const char* haystack_expr, |
---|
| 1282 | const char* needle, const char* haystack) { |
---|
| 1283 | return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); |
---|
| 1284 | } |
---|
| 1285 | |
---|
| 1286 | AssertionResult IsSubstring( |
---|
| 1287 | const char* needle_expr, const char* haystack_expr, |
---|
| 1288 | const wchar_t* needle, const wchar_t* haystack) { |
---|
| 1289 | return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); |
---|
| 1290 | } |
---|
| 1291 | |
---|
| 1292 | AssertionResult IsNotSubstring( |
---|
| 1293 | const char* needle_expr, const char* haystack_expr, |
---|
| 1294 | const char* needle, const char* haystack) { |
---|
| 1295 | return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); |
---|
| 1296 | } |
---|
| 1297 | |
---|
| 1298 | AssertionResult IsNotSubstring( |
---|
| 1299 | const char* needle_expr, const char* haystack_expr, |
---|
| 1300 | const wchar_t* needle, const wchar_t* haystack) { |
---|
| 1301 | return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); |
---|
| 1302 | } |
---|
| 1303 | |
---|
| 1304 | AssertionResult IsSubstring( |
---|
| 1305 | const char* needle_expr, const char* haystack_expr, |
---|
| 1306 | const ::std::string& needle, const ::std::string& haystack) { |
---|
| 1307 | return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); |
---|
| 1308 | } |
---|
| 1309 | |
---|
| 1310 | AssertionResult IsNotSubstring( |
---|
| 1311 | const char* needle_expr, const char* haystack_expr, |
---|
| 1312 | const ::std::string& needle, const ::std::string& haystack) { |
---|
| 1313 | return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); |
---|
| 1314 | } |
---|
| 1315 | |
---|
| 1316 | #if GTEST_HAS_STD_WSTRING |
---|
| 1317 | AssertionResult IsSubstring( |
---|
| 1318 | const char* needle_expr, const char* haystack_expr, |
---|
| 1319 | const ::std::wstring& needle, const ::std::wstring& haystack) { |
---|
| 1320 | return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); |
---|
| 1321 | } |
---|
| 1322 | |
---|
| 1323 | AssertionResult IsNotSubstring( |
---|
| 1324 | const char* needle_expr, const char* haystack_expr, |
---|
| 1325 | const ::std::wstring& needle, const ::std::wstring& haystack) { |
---|
| 1326 | return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); |
---|
| 1327 | } |
---|
| 1328 | #endif // GTEST_HAS_STD_WSTRING |
---|
| 1329 | |
---|
| 1330 | namespace internal { |
---|
| 1331 | |
---|
| 1332 | #if GTEST_OS_WINDOWS |
---|
| 1333 | |
---|
| 1334 | namespace { |
---|
| 1335 | |
---|
| 1336 | // Helper function for IsHRESULT{SuccessFailure} predicates |
---|
| 1337 | AssertionResult HRESULTFailureHelper(const char* expr, |
---|
| 1338 | const char* expected, |
---|
| 1339 | long hr) { // NOLINT |
---|
| 1340 | # if GTEST_OS_WINDOWS_MOBILE |
---|
| 1341 | |
---|
| 1342 | // Windows CE doesn't support FormatMessage. |
---|
| 1343 | const char error_text[] = ""; |
---|
| 1344 | |
---|
| 1345 | # else |
---|
| 1346 | |
---|
| 1347 | // Looks up the human-readable system message for the HRESULT code |
---|
| 1348 | // and since we're not passing any params to FormatMessage, we don't |
---|
| 1349 | // want inserts expanded. |
---|
| 1350 | const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | |
---|
| 1351 | FORMAT_MESSAGE_IGNORE_INSERTS; |
---|
| 1352 | const DWORD kBufSize = 4096; // String::Format can't exceed this length. |
---|
| 1353 | // Gets the system's human readable message string for this HRESULT. |
---|
| 1354 | char error_text[kBufSize] = { '\0' }; |
---|
| 1355 | DWORD message_length = ::FormatMessageA(kFlags, |
---|
| 1356 | 0, // no source, we're asking system |
---|
| 1357 | hr, // the error |
---|
| 1358 | 0, // no line width restrictions |
---|
| 1359 | error_text, // output buffer |
---|
| 1360 | kBufSize, // buf size |
---|
| 1361 | NULL); // no arguments for inserts |
---|
| 1362 | // Trims tailing white space (FormatMessage leaves a trailing cr-lf) |
---|
| 1363 | for (; message_length && IsSpace(error_text[message_length - 1]); |
---|
| 1364 | --message_length) { |
---|
| 1365 | error_text[message_length - 1] = '\0'; |
---|
| 1366 | } |
---|
| 1367 | |
---|
| 1368 | # endif // GTEST_OS_WINDOWS_MOBILE |
---|
| 1369 | |
---|
| 1370 | const String error_hex(String::Format("0x%08X ", hr)); |
---|
| 1371 | return ::testing::AssertionFailure() |
---|
| 1372 | << "Expected: " << expr << " " << expected << ".\n" |
---|
| 1373 | << " Actual: " << error_hex << error_text << "\n"; |
---|
| 1374 | } |
---|
| 1375 | |
---|
| 1376 | } // namespace |
---|
| 1377 | |
---|
| 1378 | AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT |
---|
| 1379 | if (SUCCEEDED(hr)) { |
---|
| 1380 | return AssertionSuccess(); |
---|
| 1381 | } |
---|
| 1382 | return HRESULTFailureHelper(expr, "succeeds", hr); |
---|
| 1383 | } |
---|
| 1384 | |
---|
| 1385 | AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT |
---|
| 1386 | if (FAILED(hr)) { |
---|
| 1387 | return AssertionSuccess(); |
---|
| 1388 | } |
---|
| 1389 | return HRESULTFailureHelper(expr, "fails", hr); |
---|
| 1390 | } |
---|
| 1391 | |
---|
| 1392 | #endif // GTEST_OS_WINDOWS |
---|
| 1393 | |
---|
| 1394 | // Utility functions for encoding Unicode text (wide strings) in |
---|
| 1395 | // UTF-8. |
---|
| 1396 | |
---|
| 1397 | // A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 |
---|
| 1398 | // like this: |
---|
| 1399 | // |
---|
| 1400 | // Code-point length Encoding |
---|
| 1401 | // 0 - 7 bits 0xxxxxxx |
---|
| 1402 | // 8 - 11 bits 110xxxxx 10xxxxxx |
---|
| 1403 | // 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx |
---|
| 1404 | // 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx |
---|
| 1405 | |
---|
| 1406 | // The maximum code-point a one-byte UTF-8 sequence can represent. |
---|
| 1407 | const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1; |
---|
| 1408 | |
---|
| 1409 | // The maximum code-point a two-byte UTF-8 sequence can represent. |
---|
| 1410 | const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1; |
---|
| 1411 | |
---|
| 1412 | // The maximum code-point a three-byte UTF-8 sequence can represent. |
---|
| 1413 | const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1; |
---|
| 1414 | |
---|
| 1415 | // The maximum code-point a four-byte UTF-8 sequence can represent. |
---|
| 1416 | const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1; |
---|
| 1417 | |
---|
| 1418 | // Chops off the n lowest bits from a bit pattern. Returns the n |
---|
| 1419 | // lowest bits. As a side effect, the original bit pattern will be |
---|
| 1420 | // shifted to the right by n bits. |
---|
| 1421 | inline UInt32 ChopLowBits(UInt32* bits, int n) { |
---|
| 1422 | const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1); |
---|
| 1423 | *bits >>= n; |
---|
| 1424 | return low_bits; |
---|
| 1425 | } |
---|
| 1426 | |
---|
| 1427 | // Converts a Unicode code point to a narrow string in UTF-8 encoding. |
---|
| 1428 | // code_point parameter is of type UInt32 because wchar_t may not be |
---|
| 1429 | // wide enough to contain a code point. |
---|
| 1430 | // The output buffer str must containt at least 32 characters. |
---|
| 1431 | // The function returns the address of the output buffer. |
---|
| 1432 | // If the code_point is not a valid Unicode code point |
---|
| 1433 | // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output |
---|
| 1434 | // as '(Invalid Unicode 0xXXXXXXXX)'. |
---|
| 1435 | char* CodePointToUtf8(UInt32 code_point, char* str) { |
---|
| 1436 | if (code_point <= kMaxCodePoint1) { |
---|
| 1437 | str[1] = '\0'; |
---|
| 1438 | str[0] = static_cast<char>(code_point); // 0xxxxxxx |
---|
| 1439 | } else if (code_point <= kMaxCodePoint2) { |
---|
| 1440 | str[2] = '\0'; |
---|
| 1441 | str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx |
---|
| 1442 | str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx |
---|
| 1443 | } else if (code_point <= kMaxCodePoint3) { |
---|
| 1444 | str[3] = '\0'; |
---|
| 1445 | str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx |
---|
| 1446 | str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx |
---|
| 1447 | str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx |
---|
| 1448 | } else if (code_point <= kMaxCodePoint4) { |
---|
| 1449 | str[4] = '\0'; |
---|
| 1450 | str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx |
---|
| 1451 | str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx |
---|
| 1452 | str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx |
---|
| 1453 | str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx |
---|
| 1454 | } else { |
---|
| 1455 | // The longest string String::Format can produce when invoked |
---|
| 1456 | // with these parameters is 28 character long (not including |
---|
| 1457 | // the terminating nul character). We are asking for 32 character |
---|
| 1458 | // buffer just in case. This is also enough for strncpy to |
---|
| 1459 | // null-terminate the destination string. |
---|
| 1460 | posix::StrNCpy( |
---|
| 1461 | str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32); |
---|
| 1462 | str[31] = '\0'; // Makes sure no change in the format to strncpy leaves |
---|
| 1463 | // the result unterminated. |
---|
| 1464 | } |
---|
| 1465 | return str; |
---|
| 1466 | } |
---|
| 1467 | |
---|
| 1468 | // The following two functions only make sense if the the system |
---|
| 1469 | // uses UTF-16 for wide string encoding. All supported systems |
---|
| 1470 | // with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. |
---|
| 1471 | |
---|
| 1472 | // Determines if the arguments constitute UTF-16 surrogate pair |
---|
| 1473 | // and thus should be combined into a single Unicode code point |
---|
| 1474 | // using CreateCodePointFromUtf16SurrogatePair. |
---|
| 1475 | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { |
---|
| 1476 | return sizeof(wchar_t) == 2 && |
---|
| 1477 | (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; |
---|
| 1478 | } |
---|
| 1479 | |
---|
| 1480 | // Creates a Unicode code point from UTF16 surrogate pair. |
---|
| 1481 | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, |
---|
| 1482 | wchar_t second) { |
---|
| 1483 | const UInt32 mask = (1 << 10) - 1; |
---|
| 1484 | return (sizeof(wchar_t) == 2) ? |
---|
| 1485 | (((first & mask) << 10) | (second & mask)) + 0x10000 : |
---|
| 1486 | // This function should not be called when the condition is |
---|
| 1487 | // false, but we provide a sensible default in case it is. |
---|
| 1488 | static_cast<UInt32>(first); |
---|
| 1489 | } |
---|
| 1490 | |
---|
| 1491 | // Converts a wide string to a narrow string in UTF-8 encoding. |
---|
| 1492 | // The wide string is assumed to have the following encoding: |
---|
| 1493 | // UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) |
---|
| 1494 | // UTF-32 if sizeof(wchar_t) == 4 (on Linux) |
---|
| 1495 | // Parameter str points to a null-terminated wide string. |
---|
| 1496 | // Parameter num_chars may additionally limit the number |
---|
| 1497 | // of wchar_t characters processed. -1 is used when the entire string |
---|
| 1498 | // should be processed. |
---|
| 1499 | // If the string contains code points that are not valid Unicode code points |
---|
| 1500 | // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output |
---|
| 1501 | // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding |
---|
| 1502 | // and contains invalid UTF-16 surrogate pairs, values in those pairs |
---|
| 1503 | // will be encoded as individual Unicode characters from Basic Normal Plane. |
---|
| 1504 | String WideStringToUtf8(const wchar_t* str, int num_chars) { |
---|
| 1505 | if (num_chars == -1) |
---|
| 1506 | num_chars = static_cast<int>(wcslen(str)); |
---|
| 1507 | |
---|
| 1508 | ::std::stringstream stream; |
---|
| 1509 | for (int i = 0; i < num_chars; ++i) { |
---|
| 1510 | UInt32 unicode_code_point; |
---|
| 1511 | |
---|
| 1512 | if (str[i] == L'\0') { |
---|
| 1513 | break; |
---|
| 1514 | } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { |
---|
| 1515 | unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], |
---|
| 1516 | str[i + 1]); |
---|
| 1517 | i++; |
---|
| 1518 | } else { |
---|
| 1519 | unicode_code_point = static_cast<UInt32>(str[i]); |
---|
| 1520 | } |
---|
| 1521 | |
---|
| 1522 | char buffer[32]; // CodePointToUtf8 requires a buffer this big. |
---|
| 1523 | stream << CodePointToUtf8(unicode_code_point, buffer); |
---|
| 1524 | } |
---|
| 1525 | return StringStreamToString(&stream); |
---|
| 1526 | } |
---|
| 1527 | |
---|
| 1528 | // Converts a wide C string to a String using the UTF-8 encoding. |
---|
| 1529 | // NULL will be converted to "(null)". |
---|
| 1530 | String String::ShowWideCString(const wchar_t * wide_c_str) { |
---|
| 1531 | if (wide_c_str == NULL) return String("(null)"); |
---|
| 1532 | |
---|
| 1533 | return String(internal::WideStringToUtf8(wide_c_str, -1).c_str()); |
---|
| 1534 | } |
---|
| 1535 | |
---|
| 1536 | // Similar to ShowWideCString(), except that this function encloses |
---|
| 1537 | // the converted string in double quotes. |
---|
| 1538 | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) { |
---|
| 1539 | if (wide_c_str == NULL) return String("(null)"); |
---|
| 1540 | |
---|
| 1541 | return String::Format("L\"%s\"", |
---|
| 1542 | String::ShowWideCString(wide_c_str).c_str()); |
---|
| 1543 | } |
---|
| 1544 | |
---|
| 1545 | // Compares two wide C strings. Returns true iff they have the same |
---|
| 1546 | // content. |
---|
| 1547 | // |
---|
| 1548 | // Unlike wcscmp(), this function can handle NULL argument(s). A NULL |
---|
| 1549 | // C string is considered different to any non-NULL C string, |
---|
| 1550 | // including the empty string. |
---|
| 1551 | bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { |
---|
| 1552 | if (lhs == NULL) return rhs == NULL; |
---|
| 1553 | |
---|
| 1554 | if (rhs == NULL) return false; |
---|
| 1555 | |
---|
| 1556 | return wcscmp(lhs, rhs) == 0; |
---|
| 1557 | } |
---|
| 1558 | |
---|
| 1559 | // Helper function for *_STREQ on wide strings. |
---|
| 1560 | AssertionResult CmpHelperSTREQ(const char* expected_expression, |
---|
| 1561 | const char* actual_expression, |
---|
| 1562 | const wchar_t* expected, |
---|
| 1563 | const wchar_t* actual) { |
---|
| 1564 | if (String::WideCStringEquals(expected, actual)) { |
---|
| 1565 | return AssertionSuccess(); |
---|
| 1566 | } |
---|
| 1567 | |
---|
| 1568 | return EqFailure(expected_expression, |
---|
| 1569 | actual_expression, |
---|
| 1570 | String::ShowWideCStringQuoted(expected), |
---|
| 1571 | String::ShowWideCStringQuoted(actual), |
---|
| 1572 | false); |
---|
| 1573 | } |
---|
| 1574 | |
---|
| 1575 | // Helper function for *_STRNE on wide strings. |
---|
| 1576 | AssertionResult CmpHelperSTRNE(const char* s1_expression, |
---|
| 1577 | const char* s2_expression, |
---|
| 1578 | const wchar_t* s1, |
---|
| 1579 | const wchar_t* s2) { |
---|
| 1580 | if (!String::WideCStringEquals(s1, s2)) { |
---|
| 1581 | return AssertionSuccess(); |
---|
| 1582 | } |
---|
| 1583 | |
---|
| 1584 | return AssertionFailure() << "Expected: (" << s1_expression << ") != (" |
---|
| 1585 | << s2_expression << "), actual: " |
---|
| 1586 | << String::ShowWideCStringQuoted(s1) |
---|
| 1587 | << " vs " << String::ShowWideCStringQuoted(s2); |
---|
| 1588 | } |
---|
| 1589 | |
---|
| 1590 | // Compares two C strings, ignoring case. Returns true iff they have |
---|
| 1591 | // the same content. |
---|
| 1592 | // |
---|
| 1593 | // Unlike strcasecmp(), this function can handle NULL argument(s). A |
---|
| 1594 | // NULL C string is considered different to any non-NULL C string, |
---|
| 1595 | // including the empty string. |
---|
| 1596 | bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { |
---|
| 1597 | if (lhs == NULL) |
---|
| 1598 | return rhs == NULL; |
---|
| 1599 | if (rhs == NULL) |
---|
| 1600 | return false; |
---|
| 1601 | return posix::StrCaseCmp(lhs, rhs) == 0; |
---|
| 1602 | } |
---|
| 1603 | |
---|
| 1604 | // Compares two wide C strings, ignoring case. Returns true iff they |
---|
| 1605 | // have the same content. |
---|
| 1606 | // |
---|
| 1607 | // Unlike wcscasecmp(), this function can handle NULL argument(s). |
---|
| 1608 | // A NULL C string is considered different to any non-NULL wide C string, |
---|
| 1609 | // including the empty string. |
---|
| 1610 | // NB: The implementations on different platforms slightly differ. |
---|
| 1611 | // On windows, this method uses _wcsicmp which compares according to LC_CTYPE |
---|
| 1612 | // environment variable. On GNU platform this method uses wcscasecmp |
---|
| 1613 | // which compares according to LC_CTYPE category of the current locale. |
---|
| 1614 | // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the |
---|
| 1615 | // current locale. |
---|
| 1616 | bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, |
---|
| 1617 | const wchar_t* rhs) { |
---|
| 1618 | if (lhs == NULL) return rhs == NULL; |
---|
| 1619 | |
---|
| 1620 | if (rhs == NULL) return false; |
---|
| 1621 | |
---|
| 1622 | #if GTEST_OS_WINDOWS |
---|
| 1623 | return _wcsicmp(lhs, rhs) == 0; |
---|
| 1624 | #elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID |
---|
| 1625 | return wcscasecmp(lhs, rhs) == 0; |
---|
| 1626 | #else |
---|
| 1627 | // Android, Mac OS X and Cygwin don't define wcscasecmp. |
---|
| 1628 | // Other unknown OSes may not define it either. |
---|
| 1629 | wint_t left, right; |
---|
| 1630 | do { |
---|
| 1631 | left = towlower(*lhs++); |
---|
| 1632 | right = towlower(*rhs++); |
---|
| 1633 | } while (left && left == right); |
---|
| 1634 | return left == right; |
---|
| 1635 | #endif // OS selector |
---|
| 1636 | } |
---|
| 1637 | |
---|
| 1638 | // Compares this with another String. |
---|
| 1639 | // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0 |
---|
| 1640 | // if this is greater than rhs. |
---|
| 1641 | int String::Compare(const String & rhs) const { |
---|
| 1642 | const char* const lhs_c_str = c_str(); |
---|
| 1643 | const char* const rhs_c_str = rhs.c_str(); |
---|
| 1644 | |
---|
| 1645 | if (lhs_c_str == NULL) { |
---|
| 1646 | return rhs_c_str == NULL ? 0 : -1; // NULL < anything except NULL |
---|
| 1647 | } else if (rhs_c_str == NULL) { |
---|
| 1648 | return 1; |
---|
| 1649 | } |
---|
| 1650 | |
---|
| 1651 | const size_t shorter_str_len = |
---|
| 1652 | length() <= rhs.length() ? length() : rhs.length(); |
---|
| 1653 | for (size_t i = 0; i != shorter_str_len; i++) { |
---|
| 1654 | if (lhs_c_str[i] < rhs_c_str[i]) { |
---|
| 1655 | return -1; |
---|
| 1656 | } else if (lhs_c_str[i] > rhs_c_str[i]) { |
---|
| 1657 | return 1; |
---|
| 1658 | } |
---|
| 1659 | } |
---|
| 1660 | return (length() < rhs.length()) ? -1 : |
---|
| 1661 | (length() > rhs.length()) ? 1 : 0; |
---|
| 1662 | } |
---|
| 1663 | |
---|
| 1664 | // Returns true iff this String ends with the given suffix. *Any* |
---|
| 1665 | // String is considered to end with a NULL or empty suffix. |
---|
| 1666 | bool String::EndsWith(const char* suffix) const { |
---|
| 1667 | if (suffix == NULL || CStringEquals(suffix, "")) return true; |
---|
| 1668 | |
---|
| 1669 | if (c_str() == NULL) return false; |
---|
| 1670 | |
---|
| 1671 | const size_t this_len = strlen(c_str()); |
---|
| 1672 | const size_t suffix_len = strlen(suffix); |
---|
| 1673 | return (this_len >= suffix_len) && |
---|
| 1674 | CStringEquals(c_str() + this_len - suffix_len, suffix); |
---|
| 1675 | } |
---|
| 1676 | |
---|
| 1677 | // Returns true iff this String ends with the given suffix, ignoring case. |
---|
| 1678 | // Any String is considered to end with a NULL or empty suffix. |
---|
| 1679 | bool String::EndsWithCaseInsensitive(const char* suffix) const { |
---|
| 1680 | if (suffix == NULL || CStringEquals(suffix, "")) return true; |
---|
| 1681 | |
---|
| 1682 | if (c_str() == NULL) return false; |
---|
| 1683 | |
---|
| 1684 | const size_t this_len = strlen(c_str()); |
---|
| 1685 | const size_t suffix_len = strlen(suffix); |
---|
| 1686 | return (this_len >= suffix_len) && |
---|
| 1687 | CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix); |
---|
| 1688 | } |
---|
| 1689 | |
---|
| 1690 | // Formats a list of arguments to a String, using the same format |
---|
| 1691 | // spec string as for printf. |
---|
| 1692 | // |
---|
| 1693 | // We do not use the StringPrintf class as it is not universally |
---|
| 1694 | // available. |
---|
| 1695 | // |
---|
| 1696 | // The result is limited to 4096 characters (including the tailing 0). |
---|
| 1697 | // If 4096 characters are not enough to format the input, or if |
---|
| 1698 | // there's an error, "<formatting error or buffer exceeded>" is |
---|
| 1699 | // returned. |
---|
| 1700 | String String::Format(const char * format, ...) { |
---|
| 1701 | va_list args; |
---|
| 1702 | va_start(args, format); |
---|
| 1703 | |
---|
| 1704 | char buffer[4096]; |
---|
| 1705 | const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]); |
---|
| 1706 | |
---|
| 1707 | // MSVC 8 deprecates vsnprintf(), so we want to suppress warning |
---|
| 1708 | // 4996 (deprecated function) there. |
---|
| 1709 | #ifdef _MSC_VER // We are using MSVC. |
---|
| 1710 | # pragma warning(push) // Saves the current warning state. |
---|
| 1711 | # pragma warning(disable:4996) // Temporarily disables warning 4996. |
---|
| 1712 | |
---|
| 1713 | const int size = vsnprintf(buffer, kBufferSize, format, args); |
---|
| 1714 | |
---|
| 1715 | # pragma warning(pop) // Restores the warning state. |
---|
| 1716 | #else // We are not using MSVC. |
---|
| 1717 | const int size = vsnprintf(buffer, kBufferSize, format, args); |
---|
| 1718 | #endif // _MSC_VER |
---|
| 1719 | va_end(args); |
---|
| 1720 | |
---|
| 1721 | // vsnprintf()'s behavior is not portable. When the buffer is not |
---|
| 1722 | // big enough, it returns a negative value in MSVC, and returns the |
---|
| 1723 | // needed buffer size on Linux. When there is an output error, it |
---|
| 1724 | // always returns a negative value. For simplicity, we lump the two |
---|
| 1725 | // error cases together. |
---|
| 1726 | if (size < 0 || size >= kBufferSize) { |
---|
| 1727 | return String("<formatting error or buffer exceeded>"); |
---|
| 1728 | } else { |
---|
| 1729 | return String(buffer, size); |
---|
| 1730 | } |
---|
| 1731 | } |
---|
| 1732 | |
---|
| 1733 | // Converts the buffer in a stringstream to a String, converting NUL |
---|
| 1734 | // bytes to "\\0" along the way. |
---|
| 1735 | String StringStreamToString(::std::stringstream* ss) { |
---|
| 1736 | const ::std::string& str = ss->str(); |
---|
| 1737 | const char* const start = str.c_str(); |
---|
| 1738 | const char* const end = start + str.length(); |
---|
| 1739 | |
---|
| 1740 | // We need to use a helper stringstream to do this transformation |
---|
| 1741 | // because String doesn't support push_back(). |
---|
| 1742 | ::std::stringstream helper; |
---|
| 1743 | for (const char* ch = start; ch != end; ++ch) { |
---|
| 1744 | if (*ch == '\0') { |
---|
| 1745 | helper << "\\0"; // Replaces NUL with "\\0"; |
---|
| 1746 | } else { |
---|
| 1747 | helper.put(*ch); |
---|
| 1748 | } |
---|
| 1749 | } |
---|
| 1750 | |
---|
| 1751 | return String(helper.str().c_str()); |
---|
| 1752 | } |
---|
| 1753 | |
---|
| 1754 | // Appends the user-supplied message to the Google-Test-generated message. |
---|
| 1755 | String AppendUserMessage(const String& gtest_msg, |
---|
| 1756 | const Message& user_msg) { |
---|
| 1757 | // Appends the user message if it's non-empty. |
---|
| 1758 | const String user_msg_string = user_msg.GetString(); |
---|
| 1759 | if (user_msg_string.empty()) { |
---|
| 1760 | return gtest_msg; |
---|
| 1761 | } |
---|
| 1762 | |
---|
| 1763 | Message msg; |
---|
| 1764 | msg << gtest_msg << "\n" << user_msg_string; |
---|
| 1765 | |
---|
| 1766 | return msg.GetString(); |
---|
| 1767 | } |
---|
| 1768 | |
---|
| 1769 | } // namespace internal |
---|
| 1770 | |
---|
| 1771 | // class TestResult |
---|
| 1772 | |
---|
| 1773 | // Creates an empty TestResult. |
---|
| 1774 | TestResult::TestResult() |
---|
| 1775 | : death_test_count_(0), |
---|
| 1776 | elapsed_time_(0) { |
---|
| 1777 | } |
---|
| 1778 | |
---|
| 1779 | // D'tor. |
---|
| 1780 | TestResult::~TestResult() { |
---|
| 1781 | } |
---|
| 1782 | |
---|
| 1783 | // Returns the i-th test part result among all the results. i can |
---|
| 1784 | // range from 0 to total_part_count() - 1. If i is not in that range, |
---|
| 1785 | // aborts the program. |
---|
| 1786 | const TestPartResult& TestResult::GetTestPartResult(int i) const { |
---|
| 1787 | if (i < 0 || i >= total_part_count()) |
---|
| 1788 | internal::posix::Abort(); |
---|
| 1789 | return test_part_results_.at(i); |
---|
| 1790 | } |
---|
| 1791 | |
---|
| 1792 | // Returns the i-th test property. i can range from 0 to |
---|
| 1793 | // test_property_count() - 1. If i is not in that range, aborts the |
---|
| 1794 | // program. |
---|
| 1795 | const TestProperty& TestResult::GetTestProperty(int i) const { |
---|
| 1796 | if (i < 0 || i >= test_property_count()) |
---|
| 1797 | internal::posix::Abort(); |
---|
| 1798 | return test_properties_.at(i); |
---|
| 1799 | } |
---|
| 1800 | |
---|
| 1801 | // Clears the test part results. |
---|
| 1802 | void TestResult::ClearTestPartResults() { |
---|
| 1803 | test_part_results_.clear(); |
---|
| 1804 | } |
---|
| 1805 | |
---|
| 1806 | // Adds a test part result to the list. |
---|
| 1807 | void TestResult::AddTestPartResult(const TestPartResult& test_part_result) { |
---|
| 1808 | test_part_results_.push_back(test_part_result); |
---|
| 1809 | } |
---|
| 1810 | |
---|
| 1811 | // Adds a test property to the list. If a property with the same key as the |
---|
| 1812 | // supplied property is already represented, the value of this test_property |
---|
| 1813 | // replaces the old value for that key. |
---|
| 1814 | void TestResult::RecordProperty(const TestProperty& test_property) { |
---|
| 1815 | if (!ValidateTestProperty(test_property)) { |
---|
| 1816 | return; |
---|
| 1817 | } |
---|
| 1818 | internal::MutexLock lock(&test_properites_mutex_); |
---|
| 1819 | const std::vector<TestProperty>::iterator property_with_matching_key = |
---|
| 1820 | std::find_if(test_properties_.begin(), test_properties_.end(), |
---|
| 1821 | internal::TestPropertyKeyIs(test_property.key())); |
---|
| 1822 | if (property_with_matching_key == test_properties_.end()) { |
---|
| 1823 | test_properties_.push_back(test_property); |
---|
| 1824 | return; |
---|
| 1825 | } |
---|
| 1826 | property_with_matching_key->SetValue(test_property.value()); |
---|
| 1827 | } |
---|
| 1828 | |
---|
| 1829 | // Adds a failure if the key is a reserved attribute of Google Test |
---|
| 1830 | // testcase tags. Returns true if the property is valid. |
---|
| 1831 | bool TestResult::ValidateTestProperty(const TestProperty& test_property) { |
---|
| 1832 | internal::String key(test_property.key()); |
---|
| 1833 | if (key == "name" || key == "status" || key == "time" || key == "classname") { |
---|
| 1834 | ADD_FAILURE() |
---|
| 1835 | << "Reserved key used in RecordProperty(): " |
---|
| 1836 | << key |
---|
| 1837 | << " ('name', 'status', 'time', and 'classname' are reserved by " |
---|
| 1838 | << GTEST_NAME_ << ")"; |
---|
| 1839 | return false; |
---|
| 1840 | } |
---|
| 1841 | return true; |
---|
| 1842 | } |
---|
| 1843 | |
---|
| 1844 | // Clears the object. |
---|
| 1845 | void TestResult::Clear() { |
---|
| 1846 | test_part_results_.clear(); |
---|
| 1847 | test_properties_.clear(); |
---|
| 1848 | death_test_count_ = 0; |
---|
| 1849 | elapsed_time_ = 0; |
---|
| 1850 | } |
---|
| 1851 | |
---|
| 1852 | // Returns true iff the test failed. |
---|
| 1853 | bool TestResult::Failed() const { |
---|
| 1854 | for (int i = 0; i < total_part_count(); ++i) { |
---|
| 1855 | if (GetTestPartResult(i).failed()) |
---|
| 1856 | return true; |
---|
| 1857 | } |
---|
| 1858 | return false; |
---|
| 1859 | } |
---|
| 1860 | |
---|
| 1861 | // Returns true iff the test part fatally failed. |
---|
| 1862 | static bool TestPartFatallyFailed(const TestPartResult& result) { |
---|
| 1863 | return result.fatally_failed(); |
---|
| 1864 | } |
---|
| 1865 | |
---|
| 1866 | // Returns true iff the test fatally failed. |
---|
| 1867 | bool TestResult::HasFatalFailure() const { |
---|
| 1868 | return CountIf(test_part_results_, TestPartFatallyFailed) > 0; |
---|
| 1869 | } |
---|
| 1870 | |
---|
| 1871 | // Returns true iff the test part non-fatally failed. |
---|
| 1872 | static bool TestPartNonfatallyFailed(const TestPartResult& result) { |
---|
| 1873 | return result.nonfatally_failed(); |
---|
| 1874 | } |
---|
| 1875 | |
---|
| 1876 | // Returns true iff the test has a non-fatal failure. |
---|
| 1877 | bool TestResult::HasNonfatalFailure() const { |
---|
| 1878 | return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; |
---|
| 1879 | } |
---|
| 1880 | |
---|
| 1881 | // Gets the number of all test parts. This is the sum of the number |
---|
| 1882 | // of successful test parts and the number of failed test parts. |
---|
| 1883 | int TestResult::total_part_count() const { |
---|
| 1884 | return static_cast<int>(test_part_results_.size()); |
---|
| 1885 | } |
---|
| 1886 | |
---|
| 1887 | // Returns the number of the test properties. |
---|
| 1888 | int TestResult::test_property_count() const { |
---|
| 1889 | return static_cast<int>(test_properties_.size()); |
---|
| 1890 | } |
---|
| 1891 | |
---|
| 1892 | // class Test |
---|
| 1893 | |
---|
| 1894 | // Creates a Test object. |
---|
| 1895 | |
---|
| 1896 | // The c'tor saves the values of all Google Test flags. |
---|
| 1897 | Test::Test() |
---|
| 1898 | : gtest_flag_saver_(new internal::GTestFlagSaver) { |
---|
| 1899 | } |
---|
| 1900 | |
---|
| 1901 | // The d'tor restores the values of all Google Test flags. |
---|
| 1902 | Test::~Test() { |
---|
| 1903 | delete gtest_flag_saver_; |
---|
| 1904 | } |
---|
| 1905 | |
---|
| 1906 | // Sets up the test fixture. |
---|
| 1907 | // |
---|
| 1908 | // A sub-class may override this. |
---|
| 1909 | void Test::SetUp() { |
---|
| 1910 | } |
---|
| 1911 | |
---|
| 1912 | // Tears down the test fixture. |
---|
| 1913 | // |
---|
| 1914 | // A sub-class may override this. |
---|
| 1915 | void Test::TearDown() { |
---|
| 1916 | } |
---|
| 1917 | |
---|
| 1918 | // Allows user supplied key value pairs to be recorded for later output. |
---|
| 1919 | void Test::RecordProperty(const char* key, const char* value) { |
---|
| 1920 | UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value); |
---|
| 1921 | } |
---|
| 1922 | |
---|
| 1923 | // Allows user supplied key value pairs to be recorded for later output. |
---|
| 1924 | void Test::RecordProperty(const char* key, int value) { |
---|
| 1925 | Message value_message; |
---|
| 1926 | value_message << value; |
---|
| 1927 | RecordProperty(key, value_message.GetString().c_str()); |
---|
| 1928 | } |
---|
| 1929 | |
---|
| 1930 | namespace internal { |
---|
| 1931 | |
---|
| 1932 | void ReportFailureInUnknownLocation(TestPartResult::Type result_type, |
---|
| 1933 | const String& message) { |
---|
| 1934 | // This function is a friend of UnitTest and as such has access to |
---|
| 1935 | // AddTestPartResult. |
---|
| 1936 | UnitTest::GetInstance()->AddTestPartResult( |
---|
| 1937 | result_type, |
---|
| 1938 | NULL, // No info about the source file where the exception occurred. |
---|
| 1939 | -1, // We have no info on which line caused the exception. |
---|
| 1940 | message, |
---|
| 1941 | String()); // No stack trace, either. |
---|
| 1942 | } |
---|
| 1943 | |
---|
| 1944 | } // namespace internal |
---|
| 1945 | |
---|
| 1946 | // Google Test requires all tests in the same test case to use the same test |
---|
| 1947 | // fixture class. This function checks if the current test has the |
---|
| 1948 | // same fixture class as the first test in the current test case. If |
---|
| 1949 | // yes, it returns true; otherwise it generates a Google Test failure and |
---|
| 1950 | // returns false. |
---|
| 1951 | bool Test::HasSameFixtureClass() { |
---|
| 1952 | internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); |
---|
| 1953 | const TestCase* const test_case = impl->current_test_case(); |
---|
| 1954 | |
---|
| 1955 | // Info about the first test in the current test case. |
---|
| 1956 | const TestInfo* const first_test_info = test_case->test_info_list()[0]; |
---|
| 1957 | const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; |
---|
| 1958 | const char* const first_test_name = first_test_info->name(); |
---|
| 1959 | |
---|
| 1960 | // Info about the current test. |
---|
| 1961 | const TestInfo* const this_test_info = impl->current_test_info(); |
---|
| 1962 | const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; |
---|
| 1963 | const char* const this_test_name = this_test_info->name(); |
---|
| 1964 | |
---|
| 1965 | if (this_fixture_id != first_fixture_id) { |
---|
| 1966 | // Is the first test defined using TEST? |
---|
| 1967 | const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); |
---|
| 1968 | // Is this test defined using TEST? |
---|
| 1969 | const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); |
---|
| 1970 | |
---|
| 1971 | if (first_is_TEST || this_is_TEST) { |
---|
| 1972 | // The user mixed TEST and TEST_F in this test case - we'll tell |
---|
| 1973 | // him/her how to fix it. |
---|
| 1974 | |
---|
| 1975 | // Gets the name of the TEST and the name of the TEST_F. Note |
---|
| 1976 | // that first_is_TEST and this_is_TEST cannot both be true, as |
---|
| 1977 | // the fixture IDs are different for the two tests. |
---|
| 1978 | const char* const TEST_name = |
---|
| 1979 | first_is_TEST ? first_test_name : this_test_name; |
---|
| 1980 | const char* const TEST_F_name = |
---|
| 1981 | first_is_TEST ? this_test_name : first_test_name; |
---|
| 1982 | |
---|
| 1983 | ADD_FAILURE() |
---|
| 1984 | << "All tests in the same test case must use the same test fixture\n" |
---|
| 1985 | << "class, so mixing TEST_F and TEST in the same test case is\n" |
---|
| 1986 | << "illegal. In test case " << this_test_info->test_case_name() |
---|
| 1987 | << ",\n" |
---|
| 1988 | << "test " << TEST_F_name << " is defined using TEST_F but\n" |
---|
| 1989 | << "test " << TEST_name << " is defined using TEST. You probably\n" |
---|
| 1990 | << "want to change the TEST to TEST_F or move it to another test\n" |
---|
| 1991 | << "case."; |
---|
| 1992 | } else { |
---|
| 1993 | // The user defined two fixture classes with the same name in |
---|
| 1994 | // two namespaces - we'll tell him/her how to fix it. |
---|
| 1995 | ADD_FAILURE() |
---|
| 1996 | << "All tests in the same test case must use the same test fixture\n" |
---|
| 1997 | << "class. However, in test case " |
---|
| 1998 | << this_test_info->test_case_name() << ",\n" |
---|
| 1999 | << "you defined test " << first_test_name |
---|
| 2000 | << " and test " << this_test_name << "\n" |
---|
| 2001 | << "using two different test fixture classes. This can happen if\n" |
---|
| 2002 | << "the two classes are from different namespaces or translation\n" |
---|
| 2003 | << "units and have the same name. You should probably rename one\n" |
---|
| 2004 | << "of the classes to put the tests into different test cases."; |
---|
| 2005 | } |
---|
| 2006 | return false; |
---|
| 2007 | } |
---|
| 2008 | |
---|
| 2009 | return true; |
---|
| 2010 | } |
---|
| 2011 | |
---|
| 2012 | #if GTEST_HAS_SEH |
---|
| 2013 | |
---|
| 2014 | // Adds an "exception thrown" fatal failure to the current test. This |
---|
| 2015 | // function returns its result via an output parameter pointer because VC++ |
---|
| 2016 | // prohibits creation of objects with destructors on stack in functions |
---|
| 2017 | // using __try (see error C2712). |
---|
| 2018 | static internal::String* FormatSehExceptionMessage(DWORD exception_code, |
---|
| 2019 | const char* location) { |
---|
| 2020 | Message message; |
---|
| 2021 | message << "SEH exception with code 0x" << std::setbase(16) << |
---|
| 2022 | exception_code << std::setbase(10) << " thrown in " << location << "."; |
---|
| 2023 | |
---|
| 2024 | return new internal::String(message.GetString()); |
---|
| 2025 | } |
---|
| 2026 | |
---|
| 2027 | #endif // GTEST_HAS_SEH |
---|
| 2028 | |
---|
| 2029 | #if GTEST_HAS_EXCEPTIONS |
---|
| 2030 | |
---|
| 2031 | // Adds an "exception thrown" fatal failure to the current test. |
---|
| 2032 | static internal::String FormatCxxExceptionMessage(const char* description, |
---|
| 2033 | const char* location) { |
---|
| 2034 | Message message; |
---|
| 2035 | if (description != NULL) { |
---|
| 2036 | message << "C++ exception with description \"" << description << "\""; |
---|
| 2037 | } else { |
---|
| 2038 | message << "Unknown C++ exception"; |
---|
| 2039 | } |
---|
| 2040 | message << " thrown in " << location << "."; |
---|
| 2041 | |
---|
| 2042 | return message.GetString(); |
---|
| 2043 | } |
---|
| 2044 | |
---|
| 2045 | static internal::String PrintTestPartResultToString( |
---|
| 2046 | const TestPartResult& test_part_result); |
---|
| 2047 | |
---|
| 2048 | // A failed Google Test assertion will throw an exception of this type when |
---|
| 2049 | // GTEST_FLAG(throw_on_failure) is true (if exceptions are enabled). We |
---|
| 2050 | // derive it from std::runtime_error, which is for errors presumably |
---|
| 2051 | // detectable only at run time. Since std::runtime_error inherits from |
---|
| 2052 | // std::exception, many testing frameworks know how to extract and print the |
---|
| 2053 | // message inside it. |
---|
| 2054 | class GoogleTestFailureException : public ::std::runtime_error { |
---|
| 2055 | public: |
---|
| 2056 | explicit GoogleTestFailureException(const TestPartResult& failure) |
---|
| 2057 | : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} |
---|
| 2058 | }; |
---|
| 2059 | #endif // GTEST_HAS_EXCEPTIONS |
---|
| 2060 | |
---|
| 2061 | namespace internal { |
---|
| 2062 | // We put these helper functions in the internal namespace as IBM's xlC |
---|
| 2063 | // compiler rejects the code if they were declared static. |
---|
| 2064 | |
---|
| 2065 | // Runs the given method and handles SEH exceptions it throws, when |
---|
| 2066 | // SEH is supported; returns the 0-value for type Result in case of an |
---|
| 2067 | // SEH exception. (Microsoft compilers cannot handle SEH and C++ |
---|
| 2068 | // exceptions in the same function. Therefore, we provide a separate |
---|
| 2069 | // wrapper function for handling SEH exceptions.) |
---|
| 2070 | template <class T, typename Result> |
---|
| 2071 | Result HandleSehExceptionsInMethodIfSupported( |
---|
| 2072 | T* object, Result (T::*method)(), const char* location) { |
---|
| 2073 | #if GTEST_HAS_SEH |
---|
| 2074 | __try { |
---|
| 2075 | return (object->*method)(); |
---|
| 2076 | } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT |
---|
| 2077 | GetExceptionCode())) { |
---|
| 2078 | // We create the exception message on the heap because VC++ prohibits |
---|
| 2079 | // creation of objects with destructors on stack in functions using __try |
---|
| 2080 | // (see error C2712). |
---|
| 2081 | internal::String* exception_message = FormatSehExceptionMessage( |
---|
| 2082 | GetExceptionCode(), location); |
---|
| 2083 | internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, |
---|
| 2084 | *exception_message); |
---|
| 2085 | delete exception_message; |
---|
| 2086 | return static_cast<Result>(0); |
---|
| 2087 | } |
---|
| 2088 | #else |
---|
| 2089 | (void)location; |
---|
| 2090 | return (object->*method)(); |
---|
| 2091 | #endif // GTEST_HAS_SEH |
---|
| 2092 | } |
---|
| 2093 | |
---|
| 2094 | // Runs the given method and catches and reports C++ and/or SEH-style |
---|
| 2095 | // exceptions, if they are supported; returns the 0-value for type |
---|
| 2096 | // Result in case of an SEH exception. |
---|
| 2097 | template <class T, typename Result> |
---|
| 2098 | Result HandleExceptionsInMethodIfSupported( |
---|
| 2099 | T* object, Result (T::*method)(), const char* location) { |
---|
| 2100 | // NOTE: The user code can affect the way in which Google Test handles |
---|
| 2101 | // exceptions by setting GTEST_FLAG(catch_exceptions), but only before |
---|
| 2102 | // RUN_ALL_TESTS() starts. It is technically possible to check the flag |
---|
| 2103 | // after the exception is caught and either report or re-throw the |
---|
| 2104 | // exception based on the flag's value: |
---|
| 2105 | // |
---|
| 2106 | // try { |
---|
| 2107 | // // Perform the test method. |
---|
| 2108 | // } catch (...) { |
---|
| 2109 | // if (GTEST_FLAG(catch_exceptions)) |
---|
| 2110 | // // Report the exception as failure. |
---|
| 2111 | // else |
---|
| 2112 | // throw; // Re-throws the original exception. |
---|
| 2113 | // } |
---|
| 2114 | // |
---|
| 2115 | // However, the purpose of this flag is to allow the program to drop into |
---|
| 2116 | // the debugger when the exception is thrown. On most platforms, once the |
---|
| 2117 | // control enters the catch block, the exception origin information is |
---|
| 2118 | // lost and the debugger will stop the program at the point of the |
---|
| 2119 | // re-throw in this function -- instead of at the point of the original |
---|
| 2120 | // throw statement in the code under test. For this reason, we perform |
---|
| 2121 | // the check early, sacrificing the ability to affect Google Test's |
---|
| 2122 | // exception handling in the method where the exception is thrown. |
---|
| 2123 | if (internal::GetUnitTestImpl()->catch_exceptions()) { |
---|
| 2124 | #if GTEST_HAS_EXCEPTIONS |
---|
| 2125 | try { |
---|
| 2126 | return HandleSehExceptionsInMethodIfSupported(object, method, location); |
---|
| 2127 | } catch (const GoogleTestFailureException&) { // NOLINT |
---|
| 2128 | // This exception doesn't originate in code under test. It makes no |
---|
| 2129 | // sense to report it as a test failure. |
---|
| 2130 | throw; |
---|
| 2131 | } catch (const std::exception& e) { // NOLINT |
---|
| 2132 | internal::ReportFailureInUnknownLocation( |
---|
| 2133 | TestPartResult::kFatalFailure, |
---|
| 2134 | FormatCxxExceptionMessage(e.what(), location)); |
---|
| 2135 | } catch (...) { // NOLINT |
---|
| 2136 | internal::ReportFailureInUnknownLocation( |
---|
| 2137 | TestPartResult::kFatalFailure, |
---|
| 2138 | FormatCxxExceptionMessage(NULL, location)); |
---|
| 2139 | } |
---|
| 2140 | return static_cast<Result>(0); |
---|
| 2141 | #else |
---|
| 2142 | return HandleSehExceptionsInMethodIfSupported(object, method, location); |
---|
| 2143 | #endif // GTEST_HAS_EXCEPTIONS |
---|
| 2144 | } else { |
---|
| 2145 | return (object->*method)(); |
---|
| 2146 | } |
---|
| 2147 | } |
---|
| 2148 | |
---|
| 2149 | } // namespace internal |
---|
| 2150 | |
---|
| 2151 | // Runs the test and updates the test result. |
---|
| 2152 | void Test::Run() { |
---|
| 2153 | if (!HasSameFixtureClass()) return; |
---|
| 2154 | |
---|
| 2155 | internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); |
---|
| 2156 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2157 | internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); |
---|
| 2158 | // We will run the test only if SetUp() was successful. |
---|
| 2159 | if (!HasFatalFailure()) { |
---|
| 2160 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2161 | internal::HandleExceptionsInMethodIfSupported( |
---|
| 2162 | this, &Test::TestBody, "the test body"); |
---|
| 2163 | } |
---|
| 2164 | |
---|
| 2165 | // However, we want to clean up as much as possible. Hence we will |
---|
| 2166 | // always call TearDown(), even if SetUp() or the test body has |
---|
| 2167 | // failed. |
---|
| 2168 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2169 | internal::HandleExceptionsInMethodIfSupported( |
---|
| 2170 | this, &Test::TearDown, "TearDown()"); |
---|
| 2171 | } |
---|
| 2172 | |
---|
| 2173 | // Returns true iff the current test has a fatal failure. |
---|
| 2174 | bool Test::HasFatalFailure() { |
---|
| 2175 | return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); |
---|
| 2176 | } |
---|
| 2177 | |
---|
| 2178 | // Returns true iff the current test has a non-fatal failure. |
---|
| 2179 | bool Test::HasNonfatalFailure() { |
---|
| 2180 | return internal::GetUnitTestImpl()->current_test_result()-> |
---|
| 2181 | HasNonfatalFailure(); |
---|
| 2182 | } |
---|
| 2183 | |
---|
| 2184 | // class TestInfo |
---|
| 2185 | |
---|
| 2186 | // Constructs a TestInfo object. It assumes ownership of the test factory |
---|
| 2187 | // object. |
---|
| 2188 | // TODO(vladl@google.com): Make a_test_case_name and a_name const string&'s |
---|
| 2189 | // to signify they cannot be NULLs. |
---|
| 2190 | TestInfo::TestInfo(const char* a_test_case_name, |
---|
| 2191 | const char* a_name, |
---|
| 2192 | const char* a_type_param, |
---|
| 2193 | const char* a_value_param, |
---|
| 2194 | internal::TypeId fixture_class_id, |
---|
| 2195 | internal::TestFactoryBase* factory) |
---|
| 2196 | : test_case_name_(a_test_case_name), |
---|
| 2197 | name_(a_name), |
---|
| 2198 | type_param_(a_type_param ? new std::string(a_type_param) : NULL), |
---|
| 2199 | value_param_(a_value_param ? new std::string(a_value_param) : NULL), |
---|
| 2200 | fixture_class_id_(fixture_class_id), |
---|
| 2201 | should_run_(false), |
---|
| 2202 | is_disabled_(false), |
---|
| 2203 | matches_filter_(false), |
---|
| 2204 | factory_(factory), |
---|
| 2205 | result_() {} |
---|
| 2206 | |
---|
| 2207 | // Destructs a TestInfo object. |
---|
| 2208 | TestInfo::~TestInfo() { delete factory_; } |
---|
| 2209 | |
---|
| 2210 | namespace internal { |
---|
| 2211 | |
---|
| 2212 | // Creates a new TestInfo object and registers it with Google Test; |
---|
| 2213 | // returns the created object. |
---|
| 2214 | // |
---|
| 2215 | // Arguments: |
---|
| 2216 | // |
---|
| 2217 | // test_case_name: name of the test case |
---|
| 2218 | // name: name of the test |
---|
| 2219 | // type_param: the name of the test's type parameter, or NULL if |
---|
| 2220 | // this is not a typed or a type-parameterized test. |
---|
| 2221 | // value_param: text representation of the test's value parameter, |
---|
| 2222 | // or NULL if this is not a value-parameterized test. |
---|
| 2223 | // fixture_class_id: ID of the test fixture class |
---|
| 2224 | // set_up_tc: pointer to the function that sets up the test case |
---|
| 2225 | // tear_down_tc: pointer to the function that tears down the test case |
---|
| 2226 | // factory: pointer to the factory that creates a test object. |
---|
| 2227 | // The newly created TestInfo instance will assume |
---|
| 2228 | // ownership of the factory object. |
---|
| 2229 | TestInfo* MakeAndRegisterTestInfo( |
---|
| 2230 | const char* test_case_name, const char* name, |
---|
| 2231 | const char* type_param, |
---|
| 2232 | const char* value_param, |
---|
| 2233 | TypeId fixture_class_id, |
---|
| 2234 | SetUpTestCaseFunc set_up_tc, |
---|
| 2235 | TearDownTestCaseFunc tear_down_tc, |
---|
| 2236 | TestFactoryBase* factory) { |
---|
| 2237 | TestInfo* const test_info = |
---|
| 2238 | new TestInfo(test_case_name, name, type_param, value_param, |
---|
| 2239 | fixture_class_id, factory); |
---|
| 2240 | GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); |
---|
| 2241 | return test_info; |
---|
| 2242 | } |
---|
| 2243 | |
---|
| 2244 | #if GTEST_HAS_PARAM_TEST |
---|
| 2245 | void ReportInvalidTestCaseType(const char* test_case_name, |
---|
| 2246 | const char* file, int line) { |
---|
| 2247 | Message errors; |
---|
| 2248 | errors |
---|
| 2249 | << "Attempted redefinition of test case " << test_case_name << ".\n" |
---|
| 2250 | << "All tests in the same test case must use the same test fixture\n" |
---|
| 2251 | << "class. However, in test case " << test_case_name << ", you tried\n" |
---|
| 2252 | << "to define a test using a fixture class different from the one\n" |
---|
| 2253 | << "used earlier. This can happen if the two fixture classes are\n" |
---|
| 2254 | << "from different namespaces and have the same name. You should\n" |
---|
| 2255 | << "probably rename one of the classes to put the tests into different\n" |
---|
| 2256 | << "test cases."; |
---|
| 2257 | |
---|
| 2258 | fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), |
---|
| 2259 | errors.GetString().c_str()); |
---|
| 2260 | } |
---|
| 2261 | #endif // GTEST_HAS_PARAM_TEST |
---|
| 2262 | |
---|
| 2263 | } // namespace internal |
---|
| 2264 | |
---|
| 2265 | namespace { |
---|
| 2266 | |
---|
| 2267 | // A predicate that checks the test name of a TestInfo against a known |
---|
| 2268 | // value. |
---|
| 2269 | // |
---|
| 2270 | // This is used for implementation of the TestCase class only. We put |
---|
| 2271 | // it in the anonymous namespace to prevent polluting the outer |
---|
| 2272 | // namespace. |
---|
| 2273 | // |
---|
| 2274 | // TestNameIs is copyable. |
---|
| 2275 | class TestNameIs { |
---|
| 2276 | public: |
---|
| 2277 | // Constructor. |
---|
| 2278 | // |
---|
| 2279 | // TestNameIs has NO default constructor. |
---|
| 2280 | explicit TestNameIs(const char* name) |
---|
| 2281 | : name_(name) {} |
---|
| 2282 | |
---|
| 2283 | // Returns true iff the test name of test_info matches name_. |
---|
| 2284 | bool operator()(const TestInfo * test_info) const { |
---|
| 2285 | return test_info && internal::String(test_info->name()).Compare(name_) == 0; |
---|
| 2286 | } |
---|
| 2287 | |
---|
| 2288 | private: |
---|
| 2289 | internal::String name_; |
---|
| 2290 | }; |
---|
| 2291 | |
---|
| 2292 | } // namespace |
---|
| 2293 | |
---|
| 2294 | namespace internal { |
---|
| 2295 | |
---|
| 2296 | // This method expands all parameterized tests registered with macros TEST_P |
---|
| 2297 | // and INSTANTIATE_TEST_CASE_P into regular tests and registers those. |
---|
| 2298 | // This will be done just once during the program runtime. |
---|
| 2299 | void UnitTestImpl::RegisterParameterizedTests() { |
---|
| 2300 | #if GTEST_HAS_PARAM_TEST |
---|
| 2301 | if (!parameterized_tests_registered_) { |
---|
| 2302 | parameterized_test_registry_.RegisterTests(); |
---|
| 2303 | parameterized_tests_registered_ = true; |
---|
| 2304 | } |
---|
| 2305 | #endif |
---|
| 2306 | } |
---|
| 2307 | |
---|
| 2308 | } // namespace internal |
---|
| 2309 | |
---|
| 2310 | // Creates the test object, runs it, records its result, and then |
---|
| 2311 | // deletes it. |
---|
| 2312 | void TestInfo::Run() { |
---|
| 2313 | if (!should_run_) return; |
---|
| 2314 | |
---|
| 2315 | // Tells UnitTest where to store test result. |
---|
| 2316 | internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); |
---|
| 2317 | impl->set_current_test_info(this); |
---|
| 2318 | |
---|
| 2319 | TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); |
---|
| 2320 | |
---|
| 2321 | // Notifies the unit test event listeners that a test is about to start. |
---|
| 2322 | repeater->OnTestStart(*this); |
---|
| 2323 | |
---|
| 2324 | const TimeInMillis start = internal::GetTimeInMillis(); |
---|
| 2325 | |
---|
| 2326 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2327 | |
---|
| 2328 | // Creates the test object. |
---|
| 2329 | Test* const test = internal::HandleExceptionsInMethodIfSupported( |
---|
| 2330 | factory_, &internal::TestFactoryBase::CreateTest, |
---|
| 2331 | "the test fixture's constructor"); |
---|
| 2332 | |
---|
| 2333 | // Runs the test only if the test object was created and its |
---|
| 2334 | // constructor didn't generate a fatal failure. |
---|
| 2335 | if ((test != NULL) && !Test::HasFatalFailure()) { |
---|
| 2336 | // This doesn't throw as all user code that can throw are wrapped into |
---|
| 2337 | // exception handling code. |
---|
| 2338 | test->Run(); |
---|
| 2339 | } |
---|
| 2340 | |
---|
| 2341 | // Deletes the test object. |
---|
| 2342 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2343 | internal::HandleExceptionsInMethodIfSupported( |
---|
| 2344 | test, &Test::DeleteSelf_, "the test fixture's destructor"); |
---|
| 2345 | |
---|
| 2346 | result_.set_elapsed_time(internal::GetTimeInMillis() - start); |
---|
| 2347 | |
---|
| 2348 | // Notifies the unit test event listener that a test has just finished. |
---|
| 2349 | repeater->OnTestEnd(*this); |
---|
| 2350 | |
---|
| 2351 | // Tells UnitTest to stop associating assertion results to this |
---|
| 2352 | // test. |
---|
| 2353 | impl->set_current_test_info(NULL); |
---|
| 2354 | } |
---|
| 2355 | |
---|
| 2356 | // class TestCase |
---|
| 2357 | |
---|
| 2358 | // Gets the number of successful tests in this test case. |
---|
| 2359 | int TestCase::successful_test_count() const { |
---|
| 2360 | return CountIf(test_info_list_, TestPassed); |
---|
| 2361 | } |
---|
| 2362 | |
---|
| 2363 | // Gets the number of failed tests in this test case. |
---|
| 2364 | int TestCase::failed_test_count() const { |
---|
| 2365 | return CountIf(test_info_list_, TestFailed); |
---|
| 2366 | } |
---|
| 2367 | |
---|
| 2368 | int TestCase::disabled_test_count() const { |
---|
| 2369 | return CountIf(test_info_list_, TestDisabled); |
---|
| 2370 | } |
---|
| 2371 | |
---|
| 2372 | // Get the number of tests in this test case that should run. |
---|
| 2373 | int TestCase::test_to_run_count() const { |
---|
| 2374 | return CountIf(test_info_list_, ShouldRunTest); |
---|
| 2375 | } |
---|
| 2376 | |
---|
| 2377 | // Gets the number of all tests. |
---|
| 2378 | int TestCase::total_test_count() const { |
---|
| 2379 | return static_cast<int>(test_info_list_.size()); |
---|
| 2380 | } |
---|
| 2381 | |
---|
| 2382 | // Creates a TestCase with the given name. |
---|
| 2383 | // |
---|
| 2384 | // Arguments: |
---|
| 2385 | // |
---|
| 2386 | // name: name of the test case |
---|
| 2387 | // a_type_param: the name of the test case's type parameter, or NULL if |
---|
| 2388 | // this is not a typed or a type-parameterized test case. |
---|
| 2389 | // set_up_tc: pointer to the function that sets up the test case |
---|
| 2390 | // tear_down_tc: pointer to the function that tears down the test case |
---|
| 2391 | TestCase::TestCase(const char* a_name, const char* a_type_param, |
---|
| 2392 | Test::SetUpTestCaseFunc set_up_tc, |
---|
| 2393 | Test::TearDownTestCaseFunc tear_down_tc) |
---|
| 2394 | : name_(a_name), |
---|
| 2395 | type_param_(a_type_param ? new std::string(a_type_param) : NULL), |
---|
| 2396 | set_up_tc_(set_up_tc), |
---|
| 2397 | tear_down_tc_(tear_down_tc), |
---|
| 2398 | should_run_(false), |
---|
| 2399 | elapsed_time_(0) { |
---|
| 2400 | } |
---|
| 2401 | |
---|
| 2402 | // Destructor of TestCase. |
---|
| 2403 | TestCase::~TestCase() { |
---|
| 2404 | // Deletes every Test in the collection. |
---|
| 2405 | ForEach(test_info_list_, internal::Delete<TestInfo>); |
---|
| 2406 | } |
---|
| 2407 | |
---|
| 2408 | // Returns the i-th test among all the tests. i can range from 0 to |
---|
| 2409 | // total_test_count() - 1. If i is not in that range, returns NULL. |
---|
| 2410 | const TestInfo* TestCase::GetTestInfo(int i) const { |
---|
| 2411 | const int index = GetElementOr(test_indices_, i, -1); |
---|
| 2412 | return index < 0 ? NULL : test_info_list_[index]; |
---|
| 2413 | } |
---|
| 2414 | |
---|
| 2415 | // Returns the i-th test among all the tests. i can range from 0 to |
---|
| 2416 | // total_test_count() - 1. If i is not in that range, returns NULL. |
---|
| 2417 | TestInfo* TestCase::GetMutableTestInfo(int i) { |
---|
| 2418 | const int index = GetElementOr(test_indices_, i, -1); |
---|
| 2419 | return index < 0 ? NULL : test_info_list_[index]; |
---|
| 2420 | } |
---|
| 2421 | |
---|
| 2422 | // Adds a test to this test case. Will delete the test upon |
---|
| 2423 | // destruction of the TestCase object. |
---|
| 2424 | void TestCase::AddTestInfo(TestInfo * test_info) { |
---|
| 2425 | test_info_list_.push_back(test_info); |
---|
| 2426 | test_indices_.push_back(static_cast<int>(test_indices_.size())); |
---|
| 2427 | } |
---|
| 2428 | |
---|
| 2429 | // Runs every test in this TestCase. |
---|
| 2430 | void TestCase::Run() { |
---|
| 2431 | if (!should_run_) return; |
---|
| 2432 | |
---|
| 2433 | internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); |
---|
| 2434 | impl->set_current_test_case(this); |
---|
| 2435 | |
---|
| 2436 | TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); |
---|
| 2437 | |
---|
| 2438 | repeater->OnTestCaseStart(*this); |
---|
| 2439 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2440 | internal::HandleExceptionsInMethodIfSupported( |
---|
| 2441 | this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); |
---|
| 2442 | |
---|
| 2443 | const internal::TimeInMillis start = internal::GetTimeInMillis(); |
---|
| 2444 | for (int i = 0; i < total_test_count(); i++) { |
---|
| 2445 | GetMutableTestInfo(i)->Run(); |
---|
| 2446 | } |
---|
| 2447 | elapsed_time_ = internal::GetTimeInMillis() - start; |
---|
| 2448 | |
---|
| 2449 | impl->os_stack_trace_getter()->UponLeavingGTest(); |
---|
| 2450 | internal::HandleExceptionsInMethodIfSupported( |
---|
| 2451 | this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); |
---|
| 2452 | |
---|
| 2453 | repeater->OnTestCaseEnd(*this); |
---|
| 2454 | impl->set_current_test_case(NULL); |
---|
| 2455 | } |
---|
| 2456 | |
---|
| 2457 | // Clears the results of all tests in this test case. |
---|
| 2458 | void TestCase::ClearResult() { |
---|
| 2459 | ForEach(test_info_list_, TestInfo::ClearTestResult); |
---|
| 2460 | } |
---|
| 2461 | |
---|
| 2462 | // Shuffles the tests in this test case. |
---|
| 2463 | void TestCase::ShuffleTests(internal::Random* random) { |
---|
| 2464 | Shuffle(random, &test_indices_); |
---|
| 2465 | } |
---|
| 2466 | |
---|
| 2467 | // Restores the test order to before the first shuffle. |
---|
| 2468 | void TestCase::UnshuffleTests() { |
---|
| 2469 | for (size_t i = 0; i < test_indices_.size(); i++) { |
---|
| 2470 | test_indices_[i] = static_cast<int>(i); |
---|
| 2471 | } |
---|
| 2472 | } |
---|
| 2473 | |
---|
| 2474 | // Formats a countable noun. Depending on its quantity, either the |
---|
| 2475 | // singular form or the plural form is used. e.g. |
---|
| 2476 | // |
---|
| 2477 | // FormatCountableNoun(1, "formula", "formuli") returns "1 formula". |
---|
| 2478 | // FormatCountableNoun(5, "book", "books") returns "5 books". |
---|
| 2479 | static internal::String FormatCountableNoun(int count, |
---|
| 2480 | const char * singular_form, |
---|
| 2481 | const char * plural_form) { |
---|
| 2482 | return internal::String::Format("%d %s", count, |
---|
| 2483 | count == 1 ? singular_form : plural_form); |
---|
| 2484 | } |
---|
| 2485 | |
---|
| 2486 | // Formats the count of tests. |
---|
| 2487 | static internal::String FormatTestCount(int test_count) { |
---|
| 2488 | return FormatCountableNoun(test_count, "test", "tests"); |
---|
| 2489 | } |
---|
| 2490 | |
---|
| 2491 | // Formats the count of test cases. |
---|
| 2492 | static internal::String FormatTestCaseCount(int test_case_count) { |
---|
| 2493 | return FormatCountableNoun(test_case_count, "test case", "test cases"); |
---|
| 2494 | } |
---|
| 2495 | |
---|
| 2496 | // Converts a TestPartResult::Type enum to human-friendly string |
---|
| 2497 | // representation. Both kNonFatalFailure and kFatalFailure are translated |
---|
| 2498 | // to "Failure", as the user usually doesn't care about the difference |
---|
| 2499 | // between the two when viewing the test result. |
---|
| 2500 | static const char * TestPartResultTypeToString(TestPartResult::Type type) { |
---|
| 2501 | switch (type) { |
---|
| 2502 | case TestPartResult::kSuccess: |
---|
| 2503 | return "Success"; |
---|
| 2504 | |
---|
| 2505 | case TestPartResult::kNonFatalFailure: |
---|
| 2506 | case TestPartResult::kFatalFailure: |
---|
| 2507 | #ifdef _MSC_VER |
---|
| 2508 | return "error: "; |
---|
| 2509 | #else |
---|
| 2510 | return "Failure\n"; |
---|
| 2511 | #endif |
---|
| 2512 | default: |
---|
| 2513 | return "Unknown result type"; |
---|
| 2514 | } |
---|
| 2515 | } |
---|
| 2516 | |
---|
| 2517 | // Prints a TestPartResult to a String. |
---|
| 2518 | static internal::String PrintTestPartResultToString( |
---|
| 2519 | const TestPartResult& test_part_result) { |
---|
| 2520 | return (Message() |
---|
| 2521 | << internal::FormatFileLocation(test_part_result.file_name(), |
---|
| 2522 | test_part_result.line_number()) |
---|
| 2523 | << " " << TestPartResultTypeToString(test_part_result.type()) |
---|
| 2524 | << test_part_result.message()).GetString(); |
---|
| 2525 | } |
---|
| 2526 | |
---|
| 2527 | // Prints a TestPartResult. |
---|
| 2528 | static void PrintTestPartResult(const TestPartResult& test_part_result) { |
---|
| 2529 | const internal::String& result = |
---|
| 2530 | PrintTestPartResultToString(test_part_result); |
---|
| 2531 | printf("%s\n", result.c_str()); |
---|
| 2532 | fflush(stdout); |
---|
| 2533 | // If the test program runs in Visual Studio or a debugger, the |
---|
| 2534 | // following statements add the test part result message to the Output |
---|
| 2535 | // window such that the user can double-click on it to jump to the |
---|
| 2536 | // corresponding source code location; otherwise they do nothing. |
---|
| 2537 | #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE |
---|
| 2538 | // We don't call OutputDebugString*() on Windows Mobile, as printing |
---|
| 2539 | // to stdout is done by OutputDebugString() there already - we don't |
---|
| 2540 | // want the same message printed twice. |
---|
| 2541 | ::OutputDebugStringA(result.c_str()); |
---|
| 2542 | ::OutputDebugStringA("\n"); |
---|
| 2543 | #endif |
---|
| 2544 | } |
---|
| 2545 | |
---|
| 2546 | // class PrettyUnitTestResultPrinter |
---|
| 2547 | |
---|
| 2548 | namespace internal { |
---|
| 2549 | |
---|
| 2550 | enum GTestColor { |
---|
| 2551 | COLOR_DEFAULT, |
---|
| 2552 | COLOR_RED, |
---|
| 2553 | COLOR_GREEN, |
---|
| 2554 | COLOR_YELLOW |
---|
| 2555 | }; |
---|
| 2556 | |
---|
| 2557 | #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE |
---|
| 2558 | |
---|
| 2559 | // Returns the character attribute for the given color. |
---|
| 2560 | WORD GetColorAttribute(GTestColor color) { |
---|
| 2561 | switch (color) { |
---|
| 2562 | case COLOR_RED: return FOREGROUND_RED; |
---|
| 2563 | case COLOR_GREEN: return FOREGROUND_GREEN; |
---|
| 2564 | case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; |
---|
| 2565 | default: return 0; |
---|
| 2566 | } |
---|
| 2567 | } |
---|
| 2568 | |
---|
| 2569 | #else |
---|
| 2570 | |
---|
| 2571 | // Returns the ANSI color code for the given color. COLOR_DEFAULT is |
---|
| 2572 | // an invalid input. |
---|
| 2573 | const char* GetAnsiColorCode(GTestColor color) { |
---|
| 2574 | switch (color) { |
---|
| 2575 | case COLOR_RED: return "1"; |
---|
| 2576 | case COLOR_GREEN: return "2"; |
---|
| 2577 | case COLOR_YELLOW: return "3"; |
---|
| 2578 | default: return NULL; |
---|
| 2579 | }; |
---|
| 2580 | } |
---|
| 2581 | |
---|
| 2582 | #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE |
---|
| 2583 | |
---|
| 2584 | // Returns true iff Google Test should use colors in the output. |
---|
| 2585 | bool ShouldUseColor(bool stdout_is_tty) { |
---|
| 2586 | const char* const gtest_color = GTEST_FLAG(color).c_str(); |
---|
| 2587 | |
---|
| 2588 | if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { |
---|
| 2589 | #if GTEST_OS_WINDOWS |
---|
| 2590 | // On Windows the TERM variable is usually not set, but the |
---|
| 2591 | // console there does support colors. |
---|
| 2592 | return stdout_is_tty; |
---|
| 2593 | #else |
---|
| 2594 | // On non-Windows platforms, we rely on the TERM variable. |
---|
| 2595 | const char* const term = posix::GetEnv("TERM"); |
---|
| 2596 | const bool term_supports_color = |
---|
| 2597 | String::CStringEquals(term, "xterm") || |
---|
| 2598 | String::CStringEquals(term, "xterm-color") || |
---|
| 2599 | String::CStringEquals(term, "xterm-256color") || |
---|
| 2600 | String::CStringEquals(term, "screen") || |
---|
| 2601 | String::CStringEquals(term, "linux") || |
---|
| 2602 | String::CStringEquals(term, "cygwin"); |
---|
| 2603 | return stdout_is_tty && term_supports_color; |
---|
| 2604 | #endif // GTEST_OS_WINDOWS |
---|
| 2605 | } |
---|
| 2606 | |
---|
| 2607 | return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || |
---|
| 2608 | String::CaseInsensitiveCStringEquals(gtest_color, "true") || |
---|
| 2609 | String::CaseInsensitiveCStringEquals(gtest_color, "t") || |
---|
| 2610 | String::CStringEquals(gtest_color, "1"); |
---|
| 2611 | // We take "yes", "true", "t", and "1" as meaning "yes". If the |
---|
| 2612 | // value is neither one of these nor "auto", we treat it as "no" to |
---|
| 2613 | // be conservative. |
---|
| 2614 | } |
---|
| 2615 | |
---|
| 2616 | // Helpers for printing colored strings to stdout. Note that on Windows, we |
---|
| 2617 | // cannot simply emit special characters and have the terminal change colors. |
---|
| 2618 | // This routine must actually emit the characters rather than return a string |
---|
| 2619 | // that would be colored when printed, as can be done on Linux. |
---|
| 2620 | void ColoredPrintf(GTestColor color, const char* fmt, ...) { |
---|
| 2621 | va_list args; |
---|
| 2622 | va_start(args, fmt); |
---|
| 2623 | |
---|
| 2624 | #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS |
---|
| 2625 | const bool use_color = false; |
---|
| 2626 | #else |
---|
| 2627 | static const bool in_color_mode = |
---|
| 2628 | ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); |
---|
| 2629 | const bool use_color = in_color_mode && (color != COLOR_DEFAULT); |
---|
| 2630 | #endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS |
---|
| 2631 | // The '!= 0' comparison is necessary to satisfy MSVC 7.1. |
---|
| 2632 | |
---|
| 2633 | if (!use_color) { |
---|
| 2634 | vprintf(fmt, args); |
---|
| 2635 | va_end(args); |
---|
| 2636 | return; |
---|
| 2637 | } |
---|
| 2638 | |
---|
| 2639 | #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE |
---|
| 2640 | const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); |
---|
| 2641 | |
---|
| 2642 | // Gets the current text color. |
---|
| 2643 | CONSOLE_SCREEN_BUFFER_INFO buffer_info; |
---|
| 2644 | GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); |
---|
| 2645 | const WORD old_color_attrs = buffer_info.wAttributes; |
---|
| 2646 | |
---|
| 2647 | // We need to flush the stream buffers into the console before each |
---|
| 2648 | // SetConsoleTextAttribute call lest it affect the text that is already |
---|
| 2649 | // printed but has not yet reached the console. |
---|
| 2650 | fflush(stdout); |
---|
| 2651 | SetConsoleTextAttribute(stdout_handle, |
---|
| 2652 | GetColorAttribute(color) | FOREGROUND_INTENSITY); |
---|
| 2653 | vprintf(fmt, args); |
---|
| 2654 | |
---|
| 2655 | fflush(stdout); |
---|
| 2656 | // Restores the text color. |
---|
| 2657 | SetConsoleTextAttribute(stdout_handle, old_color_attrs); |
---|
| 2658 | #else |
---|
| 2659 | printf("\033[0;3%sm", GetAnsiColorCode(color)); |
---|
| 2660 | vprintf(fmt, args); |
---|
| 2661 | printf("\033[m"); // Resets the terminal to default. |
---|
| 2662 | #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE |
---|
| 2663 | va_end(args); |
---|
| 2664 | } |
---|
| 2665 | |
---|
| 2666 | void PrintFullTestCommentIfPresent(const TestInfo& test_info) { |
---|
| 2667 | const char* const type_param = test_info.type_param(); |
---|
| 2668 | const char* const value_param = test_info.value_param(); |
---|
| 2669 | |
---|
| 2670 | if (type_param != NULL || value_param != NULL) { |
---|
| 2671 | printf(", where "); |
---|
| 2672 | if (type_param != NULL) { |
---|
| 2673 | printf("TypeParam = %s", type_param); |
---|
| 2674 | if (value_param != NULL) |
---|
| 2675 | printf(" and "); |
---|
| 2676 | } |
---|
| 2677 | if (value_param != NULL) { |
---|
| 2678 | printf("GetParam() = %s", value_param); |
---|
| 2679 | } |
---|
| 2680 | } |
---|
| 2681 | } |
---|
| 2682 | |
---|
| 2683 | // This class implements the TestEventListener interface. |
---|
| 2684 | // |
---|
| 2685 | // Class PrettyUnitTestResultPrinter is copyable. |
---|
| 2686 | class PrettyUnitTestResultPrinter : public TestEventListener { |
---|
| 2687 | public: |
---|
| 2688 | PrettyUnitTestResultPrinter() {} |
---|
| 2689 | static void PrintTestName(const char * test_case, const char * test) { |
---|
| 2690 | printf("%s.%s", test_case, test); |
---|
| 2691 | } |
---|
| 2692 | |
---|
| 2693 | // The following methods override what's in the TestEventListener class. |
---|
| 2694 | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} |
---|
| 2695 | virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); |
---|
| 2696 | virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); |
---|
| 2697 | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} |
---|
| 2698 | virtual void OnTestCaseStart(const TestCase& test_case); |
---|
| 2699 | virtual void OnTestStart(const TestInfo& test_info); |
---|
| 2700 | virtual void OnTestPartResult(const TestPartResult& result); |
---|
| 2701 | virtual void OnTestEnd(const TestInfo& test_info); |
---|
| 2702 | virtual void OnTestCaseEnd(const TestCase& test_case); |
---|
| 2703 | virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); |
---|
| 2704 | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} |
---|
| 2705 | virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); |
---|
| 2706 | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} |
---|
| 2707 | |
---|
| 2708 | private: |
---|
| 2709 | static void PrintFailedTests(const UnitTest& unit_test); |
---|
| 2710 | |
---|
| 2711 | internal::String test_case_name_; |
---|
| 2712 | }; |
---|
| 2713 | |
---|
| 2714 | // Fired before each iteration of tests starts. |
---|
| 2715 | void PrettyUnitTestResultPrinter::OnTestIterationStart( |
---|
| 2716 | const UnitTest& unit_test, int iteration) { |
---|
| 2717 | if (GTEST_FLAG(repeat) != 1) |
---|
| 2718 | printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); |
---|
| 2719 | |
---|
| 2720 | const char* const filter = GTEST_FLAG(filter).c_str(); |
---|
| 2721 | |
---|
| 2722 | // Prints the filter if it's not *. This reminds the user that some |
---|
| 2723 | // tests may be skipped. |
---|
| 2724 | if (!internal::String::CStringEquals(filter, kUniversalFilter)) { |
---|
| 2725 | ColoredPrintf(COLOR_YELLOW, |
---|
| 2726 | "Note: %s filter = %s\n", GTEST_NAME_, filter); |
---|
| 2727 | } |
---|
| 2728 | |
---|
| 2729 | if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { |
---|
| 2730 | const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); |
---|
| 2731 | ColoredPrintf(COLOR_YELLOW, |
---|
| 2732 | "Note: This is test shard %d of %s.\n", |
---|
| 2733 | static_cast<int>(shard_index) + 1, |
---|
| 2734 | internal::posix::GetEnv(kTestTotalShards)); |
---|
| 2735 | } |
---|
| 2736 | |
---|
| 2737 | if (GTEST_FLAG(shuffle)) { |
---|
| 2738 | ColoredPrintf(COLOR_YELLOW, |
---|
| 2739 | "Note: Randomizing tests' orders with a seed of %d .\n", |
---|
| 2740 | unit_test.random_seed()); |
---|
| 2741 | } |
---|
| 2742 | |
---|
| 2743 | ColoredPrintf(COLOR_GREEN, "[==========] "); |
---|
| 2744 | printf("Running %s from %s.\n", |
---|
| 2745 | FormatTestCount(unit_test.test_to_run_count()).c_str(), |
---|
| 2746 | FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); |
---|
| 2747 | fflush(stdout); |
---|
| 2748 | } |
---|
| 2749 | |
---|
| 2750 | void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( |
---|
| 2751 | const UnitTest& /*unit_test*/) { |
---|
| 2752 | ColoredPrintf(COLOR_GREEN, "[----------] "); |
---|
| 2753 | printf("Global test environment set-up.\n"); |
---|
| 2754 | fflush(stdout); |
---|
| 2755 | } |
---|
| 2756 | |
---|
| 2757 | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { |
---|
| 2758 | test_case_name_ = test_case.name(); |
---|
| 2759 | const internal::String counts = |
---|
| 2760 | FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); |
---|
| 2761 | ColoredPrintf(COLOR_GREEN, "[----------] "); |
---|
| 2762 | printf("%s from %s", counts.c_str(), test_case_name_.c_str()); |
---|
| 2763 | if (test_case.type_param() == NULL) { |
---|
| 2764 | printf("\n"); |
---|
| 2765 | } else { |
---|
| 2766 | printf(", where TypeParam = %s\n", test_case.type_param()); |
---|
| 2767 | } |
---|
| 2768 | fflush(stdout); |
---|
| 2769 | } |
---|
| 2770 | |
---|
| 2771 | void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { |
---|
| 2772 | ColoredPrintf(COLOR_GREEN, "[ RUN ] "); |
---|
| 2773 | PrintTestName(test_case_name_.c_str(), test_info.name()); |
---|
| 2774 | printf("\n"); |
---|
| 2775 | fflush(stdout); |
---|
| 2776 | } |
---|
| 2777 | |
---|
| 2778 | // Called after an assertion failure. |
---|
| 2779 | void PrettyUnitTestResultPrinter::OnTestPartResult( |
---|
| 2780 | const TestPartResult& result) { |
---|
| 2781 | // If the test part succeeded, we don't need to do anything. |
---|
| 2782 | if (result.type() == TestPartResult::kSuccess) |
---|
| 2783 | return; |
---|
| 2784 | |
---|
| 2785 | // Print failure message from the assertion (e.g. expected this and got that). |
---|
| 2786 | PrintTestPartResult(result); |
---|
| 2787 | fflush(stdout); |
---|
| 2788 | } |
---|
| 2789 | |
---|
| 2790 | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { |
---|
| 2791 | if (test_info.result()->Passed()) { |
---|
| 2792 | ColoredPrintf(COLOR_GREEN, "[ OK ] "); |
---|
| 2793 | } else { |
---|
| 2794 | ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
---|
| 2795 | } |
---|
| 2796 | PrintTestName(test_case_name_.c_str(), test_info.name()); |
---|
| 2797 | if (test_info.result()->Failed()) |
---|
| 2798 | PrintFullTestCommentIfPresent(test_info); |
---|
| 2799 | |
---|
| 2800 | if (GTEST_FLAG(print_time)) { |
---|
| 2801 | printf(" (%s ms)\n", internal::StreamableToString( |
---|
| 2802 | test_info.result()->elapsed_time()).c_str()); |
---|
| 2803 | } else { |
---|
| 2804 | printf("\n"); |
---|
| 2805 | } |
---|
| 2806 | fflush(stdout); |
---|
| 2807 | } |
---|
| 2808 | |
---|
| 2809 | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { |
---|
| 2810 | if (!GTEST_FLAG(print_time)) return; |
---|
| 2811 | |
---|
| 2812 | test_case_name_ = test_case.name(); |
---|
| 2813 | const internal::String counts = |
---|
| 2814 | FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); |
---|
| 2815 | ColoredPrintf(COLOR_GREEN, "[----------] "); |
---|
| 2816 | printf("%s from %s (%s ms total)\n\n", |
---|
| 2817 | counts.c_str(), test_case_name_.c_str(), |
---|
| 2818 | internal::StreamableToString(test_case.elapsed_time()).c_str()); |
---|
| 2819 | fflush(stdout); |
---|
| 2820 | } |
---|
| 2821 | |
---|
| 2822 | void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( |
---|
| 2823 | const UnitTest& /*unit_test*/) { |
---|
| 2824 | ColoredPrintf(COLOR_GREEN, "[----------] "); |
---|
| 2825 | printf("Global test environment tear-down\n"); |
---|
| 2826 | fflush(stdout); |
---|
| 2827 | } |
---|
| 2828 | |
---|
| 2829 | // Internal helper for printing the list of failed tests. |
---|
| 2830 | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { |
---|
| 2831 | const int failed_test_count = unit_test.failed_test_count(); |
---|
| 2832 | if (failed_test_count == 0) { |
---|
| 2833 | return; |
---|
| 2834 | } |
---|
| 2835 | |
---|
| 2836 | for (int i = 0; i < unit_test.total_test_case_count(); ++i) { |
---|
| 2837 | const TestCase& test_case = *unit_test.GetTestCase(i); |
---|
| 2838 | if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { |
---|
| 2839 | continue; |
---|
| 2840 | } |
---|
| 2841 | for (int j = 0; j < test_case.total_test_count(); ++j) { |
---|
| 2842 | const TestInfo& test_info = *test_case.GetTestInfo(j); |
---|
| 2843 | if (!test_info.should_run() || test_info.result()->Passed()) { |
---|
| 2844 | continue; |
---|
| 2845 | } |
---|
| 2846 | ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
---|
| 2847 | printf("%s.%s", test_case.name(), test_info.name()); |
---|
| 2848 | PrintFullTestCommentIfPresent(test_info); |
---|
| 2849 | printf("\n"); |
---|
| 2850 | } |
---|
| 2851 | } |
---|
| 2852 | } |
---|
| 2853 | |
---|
| 2854 | void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, |
---|
| 2855 | int /*iteration*/) { |
---|
| 2856 | ColoredPrintf(COLOR_GREEN, "[==========] "); |
---|
| 2857 | printf("%s from %s ran.", |
---|
| 2858 | FormatTestCount(unit_test.test_to_run_count()).c_str(), |
---|
| 2859 | FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); |
---|
| 2860 | if (GTEST_FLAG(print_time)) { |
---|
| 2861 | printf(" (%s ms total)", |
---|
| 2862 | internal::StreamableToString(unit_test.elapsed_time()).c_str()); |
---|
| 2863 | } |
---|
| 2864 | printf("\n"); |
---|
| 2865 | ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); |
---|
| 2866 | printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); |
---|
| 2867 | |
---|
| 2868 | int num_failures = unit_test.failed_test_count(); |
---|
| 2869 | if (!unit_test.Passed()) { |
---|
| 2870 | const int failed_test_count = unit_test.failed_test_count(); |
---|
| 2871 | ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
---|
| 2872 | printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); |
---|
| 2873 | PrintFailedTests(unit_test); |
---|
| 2874 | printf("\n%2d FAILED %s\n", num_failures, |
---|
| 2875 | num_failures == 1 ? "TEST" : "TESTS"); |
---|
| 2876 | } |
---|
| 2877 | |
---|
| 2878 | int num_disabled = unit_test.disabled_test_count(); |
---|
| 2879 | if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { |
---|
| 2880 | if (!num_failures) { |
---|
| 2881 | printf("\n"); // Add a spacer if no FAILURE banner is displayed. |
---|
| 2882 | } |
---|
| 2883 | ColoredPrintf(COLOR_YELLOW, |
---|
| 2884 | " YOU HAVE %d DISABLED %s\n\n", |
---|
| 2885 | num_disabled, |
---|
| 2886 | num_disabled == 1 ? "TEST" : "TESTS"); |
---|
| 2887 | } |
---|
| 2888 | // Ensure that Google Test output is printed before, e.g., heapchecker output. |
---|
| 2889 | fflush(stdout); |
---|
| 2890 | } |
---|
| 2891 | |
---|
| 2892 | // End PrettyUnitTestResultPrinter |
---|
| 2893 | |
---|
| 2894 | // class TestEventRepeater |
---|
| 2895 | // |
---|
| 2896 | // This class forwards events to other event listeners. |
---|
| 2897 | class TestEventRepeater : public TestEventListener { |
---|
| 2898 | public: |
---|
| 2899 | TestEventRepeater() : forwarding_enabled_(true) {} |
---|
| 2900 | virtual ~TestEventRepeater(); |
---|
| 2901 | void Append(TestEventListener *listener); |
---|
| 2902 | TestEventListener* Release(TestEventListener* listener); |
---|
| 2903 | |
---|
| 2904 | // Controls whether events will be forwarded to listeners_. Set to false |
---|
| 2905 | // in death test child processes. |
---|
| 2906 | bool forwarding_enabled() const { return forwarding_enabled_; } |
---|
| 2907 | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } |
---|
| 2908 | |
---|
| 2909 | virtual void OnTestProgramStart(const UnitTest& unit_test); |
---|
| 2910 | virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); |
---|
| 2911 | virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); |
---|
| 2912 | virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); |
---|
| 2913 | virtual void OnTestCaseStart(const TestCase& test_case); |
---|
| 2914 | virtual void OnTestStart(const TestInfo& test_info); |
---|
| 2915 | virtual void OnTestPartResult(const TestPartResult& result); |
---|
| 2916 | virtual void OnTestEnd(const TestInfo& test_info); |
---|
| 2917 | virtual void OnTestCaseEnd(const TestCase& test_case); |
---|
| 2918 | virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); |
---|
| 2919 | virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); |
---|
| 2920 | virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); |
---|
| 2921 | virtual void OnTestProgramEnd(const UnitTest& unit_test); |
---|
| 2922 | |
---|
| 2923 | private: |
---|
| 2924 | // Controls whether events will be forwarded to listeners_. Set to false |
---|
| 2925 | // in death test child processes. |
---|
| 2926 | bool forwarding_enabled_; |
---|
| 2927 | // The list of listeners that receive events. |
---|
| 2928 | std::vector<TestEventListener*> listeners_; |
---|
| 2929 | |
---|
| 2930 | GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); |
---|
| 2931 | }; |
---|
| 2932 | |
---|
| 2933 | TestEventRepeater::~TestEventRepeater() { |
---|
| 2934 | ForEach(listeners_, Delete<TestEventListener>); |
---|
| 2935 | } |
---|
| 2936 | |
---|
| 2937 | void TestEventRepeater::Append(TestEventListener *listener) { |
---|
| 2938 | listeners_.push_back(listener); |
---|
| 2939 | } |
---|
| 2940 | |
---|
| 2941 | // TODO(vladl@google.com): Factor the search functionality into Vector::Find. |
---|
| 2942 | TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { |
---|
| 2943 | for (size_t i = 0; i < listeners_.size(); ++i) { |
---|
| 2944 | if (listeners_[i] == listener) { |
---|
| 2945 | listeners_.erase(listeners_.begin() + i); |
---|
| 2946 | return listener; |
---|
| 2947 | } |
---|
| 2948 | } |
---|
| 2949 | |
---|
| 2950 | return NULL; |
---|
| 2951 | } |
---|
| 2952 | |
---|
| 2953 | // Since most methods are very similar, use macros to reduce boilerplate. |
---|
| 2954 | // This defines a member that forwards the call to all listeners. |
---|
| 2955 | #define GTEST_REPEATER_METHOD_(Name, Type) \ |
---|
| 2956 | void TestEventRepeater::Name(const Type& parameter) { \ |
---|
| 2957 | if (forwarding_enabled_) { \ |
---|
| 2958 | for (size_t i = 0; i < listeners_.size(); i++) { \ |
---|
| 2959 | listeners_[i]->Name(parameter); \ |
---|
| 2960 | } \ |
---|
| 2961 | } \ |
---|
| 2962 | } |
---|
| 2963 | // This defines a member that forwards the call to all listeners in reverse |
---|
| 2964 | // order. |
---|
| 2965 | #define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ |
---|
| 2966 | void TestEventRepeater::Name(const Type& parameter) { \ |
---|
| 2967 | if (forwarding_enabled_) { \ |
---|
| 2968 | for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \ |
---|
| 2969 | listeners_[i]->Name(parameter); \ |
---|
| 2970 | } \ |
---|
| 2971 | } \ |
---|
| 2972 | } |
---|
| 2973 | |
---|
| 2974 | GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) |
---|
| 2975 | GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) |
---|
| 2976 | GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) |
---|
| 2977 | GTEST_REPEATER_METHOD_(OnTestStart, TestInfo) |
---|
| 2978 | GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) |
---|
| 2979 | GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) |
---|
| 2980 | GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) |
---|
| 2981 | GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) |
---|
| 2982 | GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) |
---|
| 2983 | GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) |
---|
| 2984 | GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) |
---|
| 2985 | |
---|
| 2986 | #undef GTEST_REPEATER_METHOD_ |
---|
| 2987 | #undef GTEST_REVERSE_REPEATER_METHOD_ |
---|
| 2988 | |
---|
| 2989 | void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, |
---|
| 2990 | int iteration) { |
---|
| 2991 | if (forwarding_enabled_) { |
---|
| 2992 | for (size_t i = 0; i < listeners_.size(); i++) { |
---|
| 2993 | listeners_[i]->OnTestIterationStart(unit_test, iteration); |
---|
| 2994 | } |
---|
| 2995 | } |
---|
| 2996 | } |
---|
| 2997 | |
---|
| 2998 | void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, |
---|
| 2999 | int iteration) { |
---|
| 3000 | if (forwarding_enabled_) { |
---|
| 3001 | for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { |
---|
| 3002 | listeners_[i]->OnTestIterationEnd(unit_test, iteration); |
---|
| 3003 | } |
---|
| 3004 | } |
---|
| 3005 | } |
---|
| 3006 | |
---|
| 3007 | // End TestEventRepeater |
---|
| 3008 | |
---|
| 3009 | // This class generates an XML output file. |
---|
| 3010 | class XmlUnitTestResultPrinter : public EmptyTestEventListener { |
---|
| 3011 | public: |
---|
| 3012 | explicit XmlUnitTestResultPrinter(const char* output_file); |
---|
| 3013 | |
---|
| 3014 | virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); |
---|
| 3015 | |
---|
| 3016 | private: |
---|
| 3017 | // Is c a whitespace character that is normalized to a space character |
---|
| 3018 | // when it appears in an XML attribute value? |
---|
| 3019 | static bool IsNormalizableWhitespace(char c) { |
---|
| 3020 | return c == 0x9 || c == 0xA || c == 0xD; |
---|
| 3021 | } |
---|
| 3022 | |
---|
| 3023 | // May c appear in a well-formed XML document? |
---|
| 3024 | static bool IsValidXmlCharacter(char c) { |
---|
| 3025 | return IsNormalizableWhitespace(c) || c >= 0x20; |
---|
| 3026 | } |
---|
| 3027 | |
---|
| 3028 | // Returns an XML-escaped copy of the input string str. If |
---|
| 3029 | // is_attribute is true, the text is meant to appear as an attribute |
---|
| 3030 | // value, and normalizable whitespace is preserved by replacing it |
---|
| 3031 | // with character references. |
---|
| 3032 | static String EscapeXml(const char* str, bool is_attribute); |
---|
| 3033 | |
---|
| 3034 | // Returns the given string with all characters invalid in XML removed. |
---|
| 3035 | static string RemoveInvalidXmlCharacters(const string& str); |
---|
| 3036 | |
---|
| 3037 | // Convenience wrapper around EscapeXml when str is an attribute value. |
---|
| 3038 | static String EscapeXmlAttribute(const char* str) { |
---|
| 3039 | return EscapeXml(str, true); |
---|
| 3040 | } |
---|
| 3041 | |
---|
| 3042 | // Convenience wrapper around EscapeXml when str is not an attribute value. |
---|
| 3043 | static String EscapeXmlText(const char* str) { return EscapeXml(str, false); } |
---|
| 3044 | |
---|
| 3045 | // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. |
---|
| 3046 | static void OutputXmlCDataSection(::std::ostream* stream, const char* data); |
---|
| 3047 | |
---|
| 3048 | // Streams an XML representation of a TestInfo object. |
---|
| 3049 | static void OutputXmlTestInfo(::std::ostream* stream, |
---|
| 3050 | const char* test_case_name, |
---|
| 3051 | const TestInfo& test_info); |
---|
| 3052 | |
---|
| 3053 | // Prints an XML representation of a TestCase object |
---|
| 3054 | static void PrintXmlTestCase(FILE* out, const TestCase& test_case); |
---|
| 3055 | |
---|
| 3056 | // Prints an XML summary of unit_test to output stream out. |
---|
| 3057 | static void PrintXmlUnitTest(FILE* out, const UnitTest& unit_test); |
---|
| 3058 | |
---|
| 3059 | // Produces a string representing the test properties in a result as space |
---|
| 3060 | // delimited XML attributes based on the property key="value" pairs. |
---|
| 3061 | // When the String is not empty, it includes a space at the beginning, |
---|
| 3062 | // to delimit this attribute from prior attributes. |
---|
| 3063 | static String TestPropertiesAsXmlAttributes(const TestResult& result); |
---|
| 3064 | |
---|
| 3065 | // The output file. |
---|
| 3066 | const String output_file_; |
---|
| 3067 | |
---|
| 3068 | GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); |
---|
| 3069 | }; |
---|
| 3070 | |
---|
| 3071 | // Creates a new XmlUnitTestResultPrinter. |
---|
| 3072 | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) |
---|
| 3073 | : output_file_(output_file) { |
---|
| 3074 | if (output_file_.c_str() == NULL || output_file_.empty()) { |
---|
| 3075 | fprintf(stderr, "XML output file may not be null\n"); |
---|
| 3076 | fflush(stderr); |
---|
| 3077 | exit(EXIT_FAILURE); |
---|
| 3078 | } |
---|
| 3079 | } |
---|
| 3080 | |
---|
| 3081 | // Called after the unit test ends. |
---|
| 3082 | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, |
---|
| 3083 | int /*iteration*/) { |
---|
| 3084 | FILE* xmlout = NULL; |
---|
| 3085 | FilePath output_file(output_file_); |
---|
| 3086 | FilePath output_dir(output_file.RemoveFileName()); |
---|
| 3087 | |
---|
| 3088 | if (output_dir.CreateDirectoriesRecursively()) { |
---|
| 3089 | xmlout = posix::FOpen(output_file_.c_str(), "w"); |
---|
| 3090 | } |
---|
| 3091 | if (xmlout == NULL) { |
---|
| 3092 | // TODO(wan): report the reason of the failure. |
---|
| 3093 | // |
---|
| 3094 | // We don't do it for now as: |
---|
| 3095 | // |
---|
| 3096 | // 1. There is no urgent need for it. |
---|
| 3097 | // 2. It's a bit involved to make the errno variable thread-safe on |
---|
| 3098 | // all three operating systems (Linux, Windows, and Mac OS). |
---|
| 3099 | // 3. To interpret the meaning of errno in a thread-safe way, |
---|
| 3100 | // we need the strerror_r() function, which is not available on |
---|
| 3101 | // Windows. |
---|
| 3102 | fprintf(stderr, |
---|
| 3103 | "Unable to open file \"%s\"\n", |
---|
| 3104 | output_file_.c_str()); |
---|
| 3105 | fflush(stderr); |
---|
| 3106 | exit(EXIT_FAILURE); |
---|
| 3107 | } |
---|
| 3108 | PrintXmlUnitTest(xmlout, unit_test); |
---|
| 3109 | fclose(xmlout); |
---|
| 3110 | } |
---|
| 3111 | |
---|
| 3112 | // Returns an XML-escaped copy of the input string str. If is_attribute |
---|
| 3113 | // is true, the text is meant to appear as an attribute value, and |
---|
| 3114 | // normalizable whitespace is preserved by replacing it with character |
---|
| 3115 | // references. |
---|
| 3116 | // |
---|
| 3117 | // Invalid XML characters in str, if any, are stripped from the output. |
---|
| 3118 | // It is expected that most, if not all, of the text processed by this |
---|
| 3119 | // module will consist of ordinary English text. |
---|
| 3120 | // If this module is ever modified to produce version 1.1 XML output, |
---|
| 3121 | // most invalid characters can be retained using character references. |
---|
| 3122 | // TODO(wan): It might be nice to have a minimally invasive, human-readable |
---|
| 3123 | // escaping scheme for invalid characters, rather than dropping them. |
---|
| 3124 | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) { |
---|
| 3125 | Message m; |
---|
| 3126 | |
---|
| 3127 | if (str != NULL) { |
---|
| 3128 | for (const char* src = str; *src; ++src) { |
---|
| 3129 | switch (*src) { |
---|
| 3130 | case '<': |
---|
| 3131 | m << "<"; |
---|
| 3132 | break; |
---|
| 3133 | case '>': |
---|
| 3134 | m << ">"; |
---|
| 3135 | break; |
---|
| 3136 | case '&': |
---|
| 3137 | m << "&"; |
---|
| 3138 | break; |
---|
| 3139 | case '\'': |
---|
| 3140 | if (is_attribute) |
---|
| 3141 | m << "'"; |
---|
| 3142 | else |
---|
| 3143 | m << '\''; |
---|
| 3144 | break; |
---|
| 3145 | case '"': |
---|
| 3146 | if (is_attribute) |
---|
| 3147 | m << """; |
---|
| 3148 | else |
---|
| 3149 | m << '"'; |
---|
| 3150 | break; |
---|
| 3151 | default: |
---|
| 3152 | if (IsValidXmlCharacter(*src)) { |
---|
| 3153 | if (is_attribute && IsNormalizableWhitespace(*src)) |
---|
| 3154 | m << String::Format("&#x%02X;", unsigned(*src)); |
---|
| 3155 | else |
---|
| 3156 | m << *src; |
---|
| 3157 | } |
---|
| 3158 | break; |
---|
| 3159 | } |
---|
| 3160 | } |
---|
| 3161 | } |
---|
| 3162 | |
---|
| 3163 | return m.GetString(); |
---|
| 3164 | } |
---|
| 3165 | |
---|
| 3166 | // Returns the given string with all characters invalid in XML removed. |
---|
| 3167 | // Currently invalid characters are dropped from the string. An |
---|
| 3168 | // alternative is to replace them with certain characters such as . or ?. |
---|
| 3169 | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const string& str) { |
---|
| 3170 | string output; |
---|
| 3171 | output.reserve(str.size()); |
---|
| 3172 | for (string::const_iterator it = str.begin(); it != str.end(); ++it) |
---|
| 3173 | if (IsValidXmlCharacter(*it)) |
---|
| 3174 | output.push_back(*it); |
---|
| 3175 | |
---|
| 3176 | return output; |
---|
| 3177 | } |
---|
| 3178 | |
---|
| 3179 | // The following routines generate an XML representation of a UnitTest |
---|
| 3180 | // object. |
---|
| 3181 | // |
---|
| 3182 | // This is how Google Test concepts map to the DTD: |
---|
| 3183 | // |
---|
| 3184 | // <testsuites name="AllTests"> <-- corresponds to a UnitTest object |
---|
| 3185 | // <testsuite name="testcase-name"> <-- corresponds to a TestCase object |
---|
| 3186 | // <testcase name="test-name"> <-- corresponds to a TestInfo object |
---|
| 3187 | // <failure message="...">...</failure> |
---|
| 3188 | // <failure message="...">...</failure> |
---|
| 3189 | // <failure message="...">...</failure> |
---|
| 3190 | // <-- individual assertion failures |
---|
| 3191 | // </testcase> |
---|
| 3192 | // </testsuite> |
---|
| 3193 | // </testsuites> |
---|
| 3194 | |
---|
| 3195 | // Formats the given time in milliseconds as seconds. |
---|
| 3196 | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { |
---|
| 3197 | ::std::stringstream ss; |
---|
| 3198 | ss << ms/1000.0; |
---|
| 3199 | return ss.str(); |
---|
| 3200 | } |
---|
| 3201 | |
---|
| 3202 | // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. |
---|
| 3203 | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, |
---|
| 3204 | const char* data) { |
---|
| 3205 | const char* segment = data; |
---|
| 3206 | *stream << "<![CDATA["; |
---|
| 3207 | for (;;) { |
---|
| 3208 | const char* const next_segment = strstr(segment, "]]>"); |
---|
| 3209 | if (next_segment != NULL) { |
---|
| 3210 | stream->write( |
---|
| 3211 | segment, static_cast<std::streamsize>(next_segment - segment)); |
---|
| 3212 | *stream << "]]>]]><![CDATA["; |
---|
| 3213 | segment = next_segment + strlen("]]>"); |
---|
| 3214 | } else { |
---|
| 3215 | *stream << segment; |
---|
| 3216 | break; |
---|
| 3217 | } |
---|
| 3218 | } |
---|
| 3219 | *stream << "]]>"; |
---|
| 3220 | } |
---|
| 3221 | |
---|
| 3222 | // Prints an XML representation of a TestInfo object. |
---|
| 3223 | // TODO(wan): There is also value in printing properties with the plain printer. |
---|
| 3224 | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, |
---|
| 3225 | const char* test_case_name, |
---|
| 3226 | const TestInfo& test_info) { |
---|
| 3227 | const TestResult& result = *test_info.result(); |
---|
| 3228 | *stream << " <testcase name=\"" |
---|
| 3229 | << EscapeXmlAttribute(test_info.name()).c_str() << "\""; |
---|
| 3230 | |
---|
| 3231 | if (test_info.value_param() != NULL) { |
---|
| 3232 | *stream << " value_param=\"" << EscapeXmlAttribute(test_info.value_param()) |
---|
| 3233 | << "\""; |
---|
| 3234 | } |
---|
| 3235 | if (test_info.type_param() != NULL) { |
---|
| 3236 | *stream << " type_param=\"" << EscapeXmlAttribute(test_info.type_param()) |
---|
| 3237 | << "\""; |
---|
| 3238 | } |
---|
| 3239 | |
---|
| 3240 | *stream << " status=\"" |
---|
| 3241 | << (test_info.should_run() ? "run" : "notrun") |
---|
| 3242 | << "\" time=\"" |
---|
| 3243 | << FormatTimeInMillisAsSeconds(result.elapsed_time()) |
---|
| 3244 | << "\" classname=\"" << EscapeXmlAttribute(test_case_name).c_str() |
---|
| 3245 | << "\"" << TestPropertiesAsXmlAttributes(result).c_str(); |
---|
| 3246 | |
---|
| 3247 | int failures = 0; |
---|
| 3248 | for (int i = 0; i < result.total_part_count(); ++i) { |
---|
| 3249 | const TestPartResult& part = result.GetTestPartResult(i); |
---|
| 3250 | if (part.failed()) { |
---|
| 3251 | if (++failures == 1) |
---|
| 3252 | *stream << ">\n"; |
---|
| 3253 | *stream << " <failure message=\"" |
---|
| 3254 | << EscapeXmlAttribute(part.summary()).c_str() |
---|
| 3255 | << "\" type=\"\">"; |
---|
| 3256 | const string location = internal::FormatCompilerIndependentFileLocation( |
---|
| 3257 | part.file_name(), part.line_number()); |
---|
| 3258 | const string message = location + "\n" + part.message(); |
---|
| 3259 | OutputXmlCDataSection(stream, |
---|
| 3260 | RemoveInvalidXmlCharacters(message).c_str()); |
---|
| 3261 | *stream << "</failure>\n"; |
---|
| 3262 | } |
---|
| 3263 | } |
---|
| 3264 | |
---|
| 3265 | if (failures == 0) |
---|
| 3266 | *stream << " />\n"; |
---|
| 3267 | else |
---|
| 3268 | *stream << " </testcase>\n"; |
---|
| 3269 | } |
---|
| 3270 | |
---|
| 3271 | // Prints an XML representation of a TestCase object |
---|
| 3272 | void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out, |
---|
| 3273 | const TestCase& test_case) { |
---|
| 3274 | fprintf(out, |
---|
| 3275 | " <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" " |
---|
| 3276 | "disabled=\"%d\" ", |
---|
| 3277 | EscapeXmlAttribute(test_case.name()).c_str(), |
---|
| 3278 | test_case.total_test_count(), |
---|
| 3279 | test_case.failed_test_count(), |
---|
| 3280 | test_case.disabled_test_count()); |
---|
| 3281 | fprintf(out, |
---|
| 3282 | "errors=\"0\" time=\"%s\">\n", |
---|
| 3283 | FormatTimeInMillisAsSeconds(test_case.elapsed_time()).c_str()); |
---|
| 3284 | for (int i = 0; i < test_case.total_test_count(); ++i) { |
---|
| 3285 | ::std::stringstream stream; |
---|
| 3286 | OutputXmlTestInfo(&stream, test_case.name(), *test_case.GetTestInfo(i)); |
---|
| 3287 | fprintf(out, "%s", StringStreamToString(&stream).c_str()); |
---|
| 3288 | } |
---|
| 3289 | fprintf(out, " </testsuite>\n"); |
---|
| 3290 | } |
---|
| 3291 | |
---|
| 3292 | // Prints an XML summary of unit_test to output stream out. |
---|
| 3293 | void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out, |
---|
| 3294 | const UnitTest& unit_test) { |
---|
| 3295 | fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); |
---|
| 3296 | fprintf(out, |
---|
| 3297 | "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" " |
---|
| 3298 | "errors=\"0\" time=\"%s\" ", |
---|
| 3299 | unit_test.total_test_count(), |
---|
| 3300 | unit_test.failed_test_count(), |
---|
| 3301 | unit_test.disabled_test_count(), |
---|
| 3302 | FormatTimeInMillisAsSeconds(unit_test.elapsed_time()).c_str()); |
---|
| 3303 | if (GTEST_FLAG(shuffle)) { |
---|
| 3304 | fprintf(out, "random_seed=\"%d\" ", unit_test.random_seed()); |
---|
| 3305 | } |
---|
| 3306 | fprintf(out, "name=\"AllTests\">\n"); |
---|
| 3307 | for (int i = 0; i < unit_test.total_test_case_count(); ++i) |
---|
| 3308 | PrintXmlTestCase(out, *unit_test.GetTestCase(i)); |
---|
| 3309 | fprintf(out, "</testsuites>\n"); |
---|
| 3310 | } |
---|
| 3311 | |
---|
| 3312 | // Produces a string representing the test properties in a result as space |
---|
| 3313 | // delimited XML attributes based on the property key="value" pairs. |
---|
| 3314 | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( |
---|
| 3315 | const TestResult& result) { |
---|
| 3316 | Message attributes; |
---|
| 3317 | for (int i = 0; i < result.test_property_count(); ++i) { |
---|
| 3318 | const TestProperty& property = result.GetTestProperty(i); |
---|
| 3319 | attributes << " " << property.key() << "=" |
---|
| 3320 | << "\"" << EscapeXmlAttribute(property.value()) << "\""; |
---|
| 3321 | } |
---|
| 3322 | return attributes.GetString(); |
---|
| 3323 | } |
---|
| 3324 | |
---|
| 3325 | // End XmlUnitTestResultPrinter |
---|
| 3326 | |
---|
| 3327 | #if GTEST_CAN_STREAM_RESULTS_ |
---|
| 3328 | |
---|
| 3329 | // Streams test results to the given port on the given host machine. |
---|
| 3330 | class StreamingListener : public EmptyTestEventListener { |
---|
| 3331 | public: |
---|
| 3332 | // Escapes '=', '&', '%', and '\n' characters in str as "%xx". |
---|
| 3333 | static string UrlEncode(const char* str); |
---|
| 3334 | |
---|
| 3335 | StreamingListener(const string& host, const string& port) |
---|
| 3336 | : sockfd_(-1), host_name_(host), port_num_(port) { |
---|
| 3337 | MakeConnection(); |
---|
| 3338 | Send("gtest_streaming_protocol_version=1.0\n"); |
---|
| 3339 | } |
---|
| 3340 | |
---|
| 3341 | virtual ~StreamingListener() { |
---|
| 3342 | if (sockfd_ != -1) |
---|
| 3343 | CloseConnection(); |
---|
| 3344 | } |
---|
| 3345 | |
---|
| 3346 | void OnTestProgramStart(const UnitTest& /* unit_test */) { |
---|
| 3347 | Send("event=TestProgramStart\n"); |
---|
| 3348 | } |
---|
| 3349 | |
---|
| 3350 | void OnTestProgramEnd(const UnitTest& unit_test) { |
---|
| 3351 | // Note that Google Test current only report elapsed time for each |
---|
| 3352 | // test iteration, not for the entire test program. |
---|
| 3353 | Send(String::Format("event=TestProgramEnd&passed=%d\n", |
---|
| 3354 | unit_test.Passed())); |
---|
| 3355 | |
---|
| 3356 | // Notify the streaming server to stop. |
---|
| 3357 | CloseConnection(); |
---|
| 3358 | } |
---|
| 3359 | |
---|
| 3360 | void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) { |
---|
| 3361 | Send(String::Format("event=TestIterationStart&iteration=%d\n", |
---|
| 3362 | iteration)); |
---|
| 3363 | } |
---|
| 3364 | |
---|
| 3365 | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) { |
---|
| 3366 | Send(String::Format("event=TestIterationEnd&passed=%d&elapsed_time=%sms\n", |
---|
| 3367 | unit_test.Passed(), |
---|
| 3368 | StreamableToString(unit_test.elapsed_time()).c_str())); |
---|
| 3369 | } |
---|
| 3370 | |
---|
| 3371 | void OnTestCaseStart(const TestCase& test_case) { |
---|
| 3372 | Send(String::Format("event=TestCaseStart&name=%s\n", test_case.name())); |
---|
| 3373 | } |
---|
| 3374 | |
---|
| 3375 | void OnTestCaseEnd(const TestCase& test_case) { |
---|
| 3376 | Send(String::Format("event=TestCaseEnd&passed=%d&elapsed_time=%sms\n", |
---|
| 3377 | test_case.Passed(), |
---|
| 3378 | StreamableToString(test_case.elapsed_time()).c_str())); |
---|
| 3379 | } |
---|
| 3380 | |
---|
| 3381 | void OnTestStart(const TestInfo& test_info) { |
---|
| 3382 | Send(String::Format("event=TestStart&name=%s\n", test_info.name())); |
---|
| 3383 | } |
---|
| 3384 | |
---|
| 3385 | void OnTestEnd(const TestInfo& test_info) { |
---|
| 3386 | Send(String::Format( |
---|
| 3387 | "event=TestEnd&passed=%d&elapsed_time=%sms\n", |
---|
| 3388 | (test_info.result())->Passed(), |
---|
| 3389 | StreamableToString((test_info.result())->elapsed_time()).c_str())); |
---|
| 3390 | } |
---|
| 3391 | |
---|
| 3392 | void OnTestPartResult(const TestPartResult& test_part_result) { |
---|
| 3393 | const char* file_name = test_part_result.file_name(); |
---|
| 3394 | if (file_name == NULL) |
---|
| 3395 | file_name = ""; |
---|
| 3396 | Send(String::Format("event=TestPartResult&file=%s&line=%d&message=", |
---|
| 3397 | UrlEncode(file_name).c_str(), |
---|
| 3398 | test_part_result.line_number())); |
---|
| 3399 | Send(UrlEncode(test_part_result.message()) + "\n"); |
---|
| 3400 | } |
---|
| 3401 | |
---|
| 3402 | private: |
---|
| 3403 | // Creates a client socket and connects to the server. |
---|
| 3404 | void MakeConnection(); |
---|
| 3405 | |
---|
| 3406 | // Closes the socket. |
---|
| 3407 | void CloseConnection() { |
---|
| 3408 | GTEST_CHECK_(sockfd_ != -1) |
---|
| 3409 | << "CloseConnection() can be called only when there is a connection."; |
---|
| 3410 | |
---|
| 3411 | close(sockfd_); |
---|
| 3412 | sockfd_ = -1; |
---|
| 3413 | } |
---|
| 3414 | |
---|
| 3415 | // Sends a string to the socket. |
---|
| 3416 | void Send(const string& message) { |
---|
| 3417 | GTEST_CHECK_(sockfd_ != -1) |
---|
| 3418 | << "Send() can be called only when there is a connection."; |
---|
| 3419 | |
---|
| 3420 | const int len = static_cast<int>(message.length()); |
---|
| 3421 | if (write(sockfd_, message.c_str(), len) != len) { |
---|
| 3422 | GTEST_LOG_(WARNING) |
---|
| 3423 | << "stream_result_to: failed to stream to " |
---|
| 3424 | << host_name_ << ":" << port_num_; |
---|
| 3425 | } |
---|
| 3426 | } |
---|
| 3427 | |
---|
| 3428 | int sockfd_; // socket file descriptor |
---|
| 3429 | const string host_name_; |
---|
| 3430 | const string port_num_; |
---|
| 3431 | |
---|
| 3432 | GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); |
---|
| 3433 | }; // class StreamingListener |
---|
| 3434 | |
---|
| 3435 | // Checks if str contains '=', '&', '%' or '\n' characters. If yes, |
---|
| 3436 | // replaces them by "%xx" where xx is their hexadecimal value. For |
---|
| 3437 | // example, replaces "=" with "%3D". This algorithm is O(strlen(str)) |
---|
| 3438 | // in both time and space -- important as the input str may contain an |
---|
| 3439 | // arbitrarily long test failure message and stack trace. |
---|
| 3440 | string StreamingListener::UrlEncode(const char* str) { |
---|
| 3441 | string result; |
---|
| 3442 | result.reserve(strlen(str) + 1); |
---|
| 3443 | for (char ch = *str; ch != '\0'; ch = *++str) { |
---|
| 3444 | switch (ch) { |
---|
| 3445 | case '%': |
---|
| 3446 | case '=': |
---|
| 3447 | case '&': |
---|
| 3448 | case '\n': |
---|
| 3449 | result.append(String::Format("%%%02x", static_cast<unsigned char>(ch))); |
---|
| 3450 | break; |
---|
| 3451 | default: |
---|
| 3452 | result.push_back(ch); |
---|
| 3453 | break; |
---|
| 3454 | } |
---|
| 3455 | } |
---|
| 3456 | return result; |
---|
| 3457 | } |
---|
| 3458 | |
---|
| 3459 | void StreamingListener::MakeConnection() { |
---|
| 3460 | GTEST_CHECK_(sockfd_ == -1) |
---|
| 3461 | << "MakeConnection() can't be called when there is already a connection."; |
---|
| 3462 | |
---|
| 3463 | addrinfo hints; |
---|
| 3464 | memset(&hints, 0, sizeof(hints)); |
---|
| 3465 | hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. |
---|
| 3466 | hints.ai_socktype = SOCK_STREAM; |
---|
| 3467 | addrinfo* servinfo = NULL; |
---|
| 3468 | |
---|
| 3469 | // Use the getaddrinfo() to get a linked list of IP addresses for |
---|
| 3470 | // the given host name. |
---|
| 3471 | const int error_num = getaddrinfo( |
---|
| 3472 | host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); |
---|
| 3473 | if (error_num != 0) { |
---|
| 3474 | GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " |
---|
| 3475 | << gai_strerror(error_num); |
---|
| 3476 | } |
---|
| 3477 | |
---|
| 3478 | // Loop through all the results and connect to the first we can. |
---|
| 3479 | for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; |
---|
| 3480 | cur_addr = cur_addr->ai_next) { |
---|
| 3481 | sockfd_ = socket( |
---|
| 3482 | cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); |
---|
| 3483 | if (sockfd_ != -1) { |
---|
| 3484 | // Connect the client socket to the server socket. |
---|
| 3485 | if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { |
---|
| 3486 | close(sockfd_); |
---|
| 3487 | sockfd_ = -1; |
---|
| 3488 | } |
---|
| 3489 | } |
---|
| 3490 | } |
---|
| 3491 | |
---|
| 3492 | freeaddrinfo(servinfo); // all done with this structure |
---|
| 3493 | |
---|
| 3494 | if (sockfd_ == -1) { |
---|
| 3495 | GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " |
---|
| 3496 | << host_name_ << ":" << port_num_; |
---|
| 3497 | } |
---|
| 3498 | } |
---|
| 3499 | |
---|
| 3500 | // End of class Streaming Listener |
---|
| 3501 | #endif // GTEST_CAN_STREAM_RESULTS__ |
---|
| 3502 | |
---|
| 3503 | // Class ScopedTrace |
---|
| 3504 | |
---|
| 3505 | // Pushes the given source file location and message onto a per-thread |
---|
| 3506 | // trace stack maintained by Google Test. |
---|
| 3507 | // L < UnitTest::mutex_ |
---|
| 3508 | ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) { |
---|
| 3509 | TraceInfo trace; |
---|
| 3510 | trace.file = file; |
---|
| 3511 | trace.line = line; |
---|
| 3512 | trace.message = message.GetString(); |
---|
| 3513 | |
---|
| 3514 | UnitTest::GetInstance()->PushGTestTrace(trace); |
---|
| 3515 | } |
---|
| 3516 | |
---|
| 3517 | // Pops the info pushed by the c'tor. |
---|
| 3518 | // L < UnitTest::mutex_ |
---|
| 3519 | ScopedTrace::~ScopedTrace() { |
---|
| 3520 | UnitTest::GetInstance()->PopGTestTrace(); |
---|
| 3521 | } |
---|
| 3522 | |
---|
| 3523 | |
---|
| 3524 | // class OsStackTraceGetter |
---|
| 3525 | |
---|
| 3526 | // Returns the current OS stack trace as a String. Parameters: |
---|
| 3527 | // |
---|
| 3528 | // max_depth - the maximum number of stack frames to be included |
---|
| 3529 | // in the trace. |
---|
| 3530 | // skip_count - the number of top frames to be skipped; doesn't count |
---|
| 3531 | // against max_depth. |
---|
| 3532 | // |
---|
| 3533 | // L < mutex_ |
---|
| 3534 | // We use "L < mutex_" to denote that the function may acquire mutex_. |
---|
| 3535 | String OsStackTraceGetter::CurrentStackTrace(int, int) { |
---|
| 3536 | return String(""); |
---|
| 3537 | } |
---|
| 3538 | |
---|
| 3539 | // L < mutex_ |
---|
| 3540 | void OsStackTraceGetter::UponLeavingGTest() { |
---|
| 3541 | } |
---|
| 3542 | |
---|
| 3543 | const char* const |
---|
| 3544 | OsStackTraceGetter::kElidedFramesMarker = |
---|
| 3545 | "... " GTEST_NAME_ " internal frames ..."; |
---|
| 3546 | |
---|
| 3547 | } // namespace internal |
---|
| 3548 | |
---|
| 3549 | // class TestEventListeners |
---|
| 3550 | |
---|
| 3551 | TestEventListeners::TestEventListeners() |
---|
| 3552 | : repeater_(new internal::TestEventRepeater()), |
---|
| 3553 | default_result_printer_(NULL), |
---|
| 3554 | default_xml_generator_(NULL) { |
---|
| 3555 | } |
---|
| 3556 | |
---|
| 3557 | TestEventListeners::~TestEventListeners() { delete repeater_; } |
---|
| 3558 | |
---|
| 3559 | // Returns the standard listener responsible for the default console |
---|
| 3560 | // output. Can be removed from the listeners list to shut down default |
---|
| 3561 | // console output. Note that removing this object from the listener list |
---|
| 3562 | // with Release transfers its ownership to the user. |
---|
| 3563 | void TestEventListeners::Append(TestEventListener* listener) { |
---|
| 3564 | repeater_->Append(listener); |
---|
| 3565 | } |
---|
| 3566 | |
---|
| 3567 | // Removes the given event listener from the list and returns it. It then |
---|
| 3568 | // becomes the caller's responsibility to delete the listener. Returns |
---|
| 3569 | // NULL if the listener is not found in the list. |
---|
| 3570 | TestEventListener* TestEventListeners::Release(TestEventListener* listener) { |
---|
| 3571 | if (listener == default_result_printer_) |
---|
| 3572 | default_result_printer_ = NULL; |
---|
| 3573 | else if (listener == default_xml_generator_) |
---|
| 3574 | default_xml_generator_ = NULL; |
---|
| 3575 | return repeater_->Release(listener); |
---|
| 3576 | } |
---|
| 3577 | |
---|
| 3578 | // Returns repeater that broadcasts the TestEventListener events to all |
---|
| 3579 | // subscribers. |
---|
| 3580 | TestEventListener* TestEventListeners::repeater() { return repeater_; } |
---|
| 3581 | |
---|
| 3582 | // Sets the default_result_printer attribute to the provided listener. |
---|
| 3583 | // The listener is also added to the listener list and previous |
---|
| 3584 | // default_result_printer is removed from it and deleted. The listener can |
---|
| 3585 | // also be NULL in which case it will not be added to the list. Does |
---|
| 3586 | // nothing if the previous and the current listener objects are the same. |
---|
| 3587 | void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { |
---|
| 3588 | if (default_result_printer_ != listener) { |
---|
| 3589 | // It is an error to pass this method a listener that is already in the |
---|
| 3590 | // list. |
---|
| 3591 | delete Release(default_result_printer_); |
---|
| 3592 | default_result_printer_ = listener; |
---|
| 3593 | if (listener != NULL) |
---|
| 3594 | Append(listener); |
---|
| 3595 | } |
---|
| 3596 | } |
---|
| 3597 | |
---|
| 3598 | // Sets the default_xml_generator attribute to the provided listener. The |
---|
| 3599 | // listener is also added to the listener list and previous |
---|
| 3600 | // default_xml_generator is removed from it and deleted. The listener can |
---|
| 3601 | // also be NULL in which case it will not be added to the list. Does |
---|
| 3602 | // nothing if the previous and the current listener objects are the same. |
---|
| 3603 | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { |
---|
| 3604 | if (default_xml_generator_ != listener) { |
---|
| 3605 | // It is an error to pass this method a listener that is already in the |
---|
| 3606 | // list. |
---|
| 3607 | delete Release(default_xml_generator_); |
---|
| 3608 | default_xml_generator_ = listener; |
---|
| 3609 | if (listener != NULL) |
---|
| 3610 | Append(listener); |
---|
| 3611 | } |
---|
| 3612 | } |
---|
| 3613 | |
---|
| 3614 | // Controls whether events will be forwarded by the repeater to the |
---|
| 3615 | // listeners in the list. |
---|
| 3616 | bool TestEventListeners::EventForwardingEnabled() const { |
---|
| 3617 | return repeater_->forwarding_enabled(); |
---|
| 3618 | } |
---|
| 3619 | |
---|
| 3620 | void TestEventListeners::SuppressEventForwarding() { |
---|
| 3621 | repeater_->set_forwarding_enabled(false); |
---|
| 3622 | } |
---|
| 3623 | |
---|
| 3624 | // class UnitTest |
---|
| 3625 | |
---|
| 3626 | // Gets the singleton UnitTest object. The first time this method is |
---|
| 3627 | // called, a UnitTest object is constructed and returned. Consecutive |
---|
| 3628 | // calls will return the same object. |
---|
| 3629 | // |
---|
| 3630 | // We don't protect this under mutex_ as a user is not supposed to |
---|
| 3631 | // call this before main() starts, from which point on the return |
---|
| 3632 | // value will never change. |
---|
| 3633 | UnitTest * UnitTest::GetInstance() { |
---|
| 3634 | // When compiled with MSVC 7.1 in optimized mode, destroying the |
---|
| 3635 | // UnitTest object upon exiting the program messes up the exit code, |
---|
| 3636 | // causing successful tests to appear failed. We have to use a |
---|
| 3637 | // different implementation in this case to bypass the compiler bug. |
---|
| 3638 | // This implementation makes the compiler happy, at the cost of |
---|
| 3639 | // leaking the UnitTest object. |
---|
| 3640 | |
---|
| 3641 | // CodeGear C++Builder insists on a public destructor for the |
---|
| 3642 | // default implementation. Use this implementation to keep good OO |
---|
| 3643 | // design with private destructor. |
---|
| 3644 | |
---|
| 3645 | #if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) |
---|
| 3646 | static UnitTest* const instance = new UnitTest; |
---|
| 3647 | return instance; |
---|
| 3648 | #else |
---|
| 3649 | static UnitTest instance; |
---|
| 3650 | return &instance; |
---|
| 3651 | #endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) |
---|
| 3652 | } |
---|
| 3653 | |
---|
| 3654 | // Gets the number of successful test cases. |
---|
| 3655 | int UnitTest::successful_test_case_count() const { |
---|
| 3656 | return impl()->successful_test_case_count(); |
---|
| 3657 | } |
---|
| 3658 | |
---|
| 3659 | // Gets the number of failed test cases. |
---|
| 3660 | int UnitTest::failed_test_case_count() const { |
---|
| 3661 | return impl()->failed_test_case_count(); |
---|
| 3662 | } |
---|
| 3663 | |
---|
| 3664 | // Gets the number of all test cases. |
---|
| 3665 | int UnitTest::total_test_case_count() const { |
---|
| 3666 | return impl()->total_test_case_count(); |
---|
| 3667 | } |
---|
| 3668 | |
---|
| 3669 | // Gets the number of all test cases that contain at least one test |
---|
| 3670 | // that should run. |
---|
| 3671 | int UnitTest::test_case_to_run_count() const { |
---|
| 3672 | return impl()->test_case_to_run_count(); |
---|
| 3673 | } |
---|
| 3674 | |
---|
| 3675 | // Gets the number of successful tests. |
---|
| 3676 | int UnitTest::successful_test_count() const { |
---|
| 3677 | return impl()->successful_test_count(); |
---|
| 3678 | } |
---|
| 3679 | |
---|
| 3680 | // Gets the number of failed tests. |
---|
| 3681 | int UnitTest::failed_test_count() const { return impl()->failed_test_count(); } |
---|
| 3682 | |
---|
| 3683 | // Gets the number of disabled tests. |
---|
| 3684 | int UnitTest::disabled_test_count() const { |
---|
| 3685 | return impl()->disabled_test_count(); |
---|
| 3686 | } |
---|
| 3687 | |
---|
| 3688 | // Gets the number of all tests. |
---|
| 3689 | int UnitTest::total_test_count() const { return impl()->total_test_count(); } |
---|
| 3690 | |
---|
| 3691 | // Gets the number of tests that should run. |
---|
| 3692 | int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } |
---|
| 3693 | |
---|
| 3694 | // Gets the elapsed time, in milliseconds. |
---|
| 3695 | internal::TimeInMillis UnitTest::elapsed_time() const { |
---|
| 3696 | return impl()->elapsed_time(); |
---|
| 3697 | } |
---|
| 3698 | |
---|
| 3699 | // Returns true iff the unit test passed (i.e. all test cases passed). |
---|
| 3700 | bool UnitTest::Passed() const { return impl()->Passed(); } |
---|
| 3701 | |
---|
| 3702 | // Returns true iff the unit test failed (i.e. some test case failed |
---|
| 3703 | // or something outside of all tests failed). |
---|
| 3704 | bool UnitTest::Failed() const { return impl()->Failed(); } |
---|
| 3705 | |
---|
| 3706 | // Gets the i-th test case among all the test cases. i can range from 0 to |
---|
| 3707 | // total_test_case_count() - 1. If i is not in that range, returns NULL. |
---|
| 3708 | const TestCase* UnitTest::GetTestCase(int i) const { |
---|
| 3709 | return impl()->GetTestCase(i); |
---|
| 3710 | } |
---|
| 3711 | |
---|
| 3712 | // Gets the i-th test case among all the test cases. i can range from 0 to |
---|
| 3713 | // total_test_case_count() - 1. If i is not in that range, returns NULL. |
---|
| 3714 | TestCase* UnitTest::GetMutableTestCase(int i) { |
---|
| 3715 | return impl()->GetMutableTestCase(i); |
---|
| 3716 | } |
---|
| 3717 | |
---|
| 3718 | // Returns the list of event listeners that can be used to track events |
---|
| 3719 | // inside Google Test. |
---|
| 3720 | TestEventListeners& UnitTest::listeners() { |
---|
| 3721 | return *impl()->listeners(); |
---|
| 3722 | } |
---|
| 3723 | |
---|
| 3724 | // Registers and returns a global test environment. When a test |
---|
| 3725 | // program is run, all global test environments will be set-up in the |
---|
| 3726 | // order they were registered. After all tests in the program have |
---|
| 3727 | // finished, all global test environments will be torn-down in the |
---|
| 3728 | // *reverse* order they were registered. |
---|
| 3729 | // |
---|
| 3730 | // The UnitTest object takes ownership of the given environment. |
---|
| 3731 | // |
---|
| 3732 | // We don't protect this under mutex_, as we only support calling it |
---|
| 3733 | // from the main thread. |
---|
| 3734 | Environment* UnitTest::AddEnvironment(Environment* env) { |
---|
| 3735 | if (env == NULL) { |
---|
| 3736 | return NULL; |
---|
| 3737 | } |
---|
| 3738 | |
---|
| 3739 | impl_->environments().push_back(env); |
---|
| 3740 | return env; |
---|
| 3741 | } |
---|
| 3742 | |
---|
| 3743 | // Adds a TestPartResult to the current TestResult object. All Google Test |
---|
| 3744 | // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call |
---|
| 3745 | // this to report their results. The user code should use the |
---|
| 3746 | // assertion macros instead of calling this directly. |
---|
| 3747 | // L < mutex_ |
---|
| 3748 | void UnitTest::AddTestPartResult(TestPartResult::Type result_type, |
---|
| 3749 | const char* file_name, |
---|
| 3750 | int line_number, |
---|
| 3751 | const internal::String& message, |
---|
| 3752 | const internal::String& os_stack_trace) { |
---|
| 3753 | Message msg; |
---|
| 3754 | msg << message; |
---|
| 3755 | |
---|
| 3756 | internal::MutexLock lock(&mutex_); |
---|
| 3757 | if (impl_->gtest_trace_stack().size() > 0) { |
---|
| 3758 | msg << "\n" << GTEST_NAME_ << " trace:"; |
---|
| 3759 | |
---|
| 3760 | for (int i = static_cast<int>(impl_->gtest_trace_stack().size()); |
---|
| 3761 | i > 0; --i) { |
---|
| 3762 | const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; |
---|
| 3763 | msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) |
---|
| 3764 | << " " << trace.message; |
---|
| 3765 | } |
---|
| 3766 | } |
---|
| 3767 | |
---|
| 3768 | if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { |
---|
| 3769 | msg << internal::kStackTraceMarker << os_stack_trace; |
---|
| 3770 | } |
---|
| 3771 | |
---|
| 3772 | const TestPartResult result = |
---|
| 3773 | TestPartResult(result_type, file_name, line_number, |
---|
| 3774 | msg.GetString().c_str()); |
---|
| 3775 | impl_->GetTestPartResultReporterForCurrentThread()-> |
---|
| 3776 | ReportTestPartResult(result); |
---|
| 3777 | |
---|
| 3778 | if (result_type != TestPartResult::kSuccess) { |
---|
| 3779 | // gtest_break_on_failure takes precedence over |
---|
| 3780 | // gtest_throw_on_failure. This allows a user to set the latter |
---|
| 3781 | // in the code (perhaps in order to use Google Test assertions |
---|
| 3782 | // with another testing framework) and specify the former on the |
---|
| 3783 | // command line for debugging. |
---|
| 3784 | if (GTEST_FLAG(break_on_failure)) { |
---|
| 3785 | #if GTEST_OS_WINDOWS |
---|
| 3786 | // Using DebugBreak on Windows allows gtest to still break into a debugger |
---|
| 3787 | // when a failure happens and both the --gtest_break_on_failure and |
---|
| 3788 | // the --gtest_catch_exceptions flags are specified. |
---|
| 3789 | DebugBreak(); |
---|
| 3790 | #else |
---|
| 3791 | // Dereference NULL through a volatile pointer to prevent the compiler |
---|
| 3792 | // from removing. We use this rather than abort() or __builtin_trap() for |
---|
| 3793 | // portability: Symbian doesn't implement abort() well, and some debuggers |
---|
| 3794 | // don't correctly trap abort(). |
---|
| 3795 | *static_cast<volatile int*>(NULL) = 1; |
---|
| 3796 | #endif // GTEST_OS_WINDOWS |
---|
| 3797 | } else if (GTEST_FLAG(throw_on_failure)) { |
---|
| 3798 | #if GTEST_HAS_EXCEPTIONS |
---|
| 3799 | throw GoogleTestFailureException(result); |
---|
| 3800 | #else |
---|
| 3801 | // We cannot call abort() as it generates a pop-up in debug mode |
---|
| 3802 | // that cannot be suppressed in VC 7.1 or below. |
---|
| 3803 | exit(1); |
---|
| 3804 | #endif |
---|
| 3805 | } |
---|
| 3806 | } |
---|
| 3807 | } |
---|
| 3808 | |
---|
| 3809 | // Creates and adds a property to the current TestResult. If a property matching |
---|
| 3810 | // the supplied value already exists, updates its value instead. |
---|
| 3811 | void UnitTest::RecordPropertyForCurrentTest(const char* key, |
---|
| 3812 | const char* value) { |
---|
| 3813 | const TestProperty test_property(key, value); |
---|
| 3814 | impl_->current_test_result()->RecordProperty(test_property); |
---|
| 3815 | } |
---|
| 3816 | |
---|
| 3817 | // Runs all tests in this UnitTest object and prints the result. |
---|
| 3818 | // Returns 0 if successful, or 1 otherwise. |
---|
| 3819 | // |
---|
| 3820 | // We don't protect this under mutex_, as we only support calling it |
---|
| 3821 | // from the main thread. |
---|
| 3822 | int UnitTest::Run() { |
---|
| 3823 | // Captures the value of GTEST_FLAG(catch_exceptions). This value will be |
---|
| 3824 | // used for the duration of the program. |
---|
| 3825 | impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); |
---|
| 3826 | |
---|
| 3827 | #if GTEST_HAS_SEH || GTEST_OS_WINDOWS_MINGW |
---|
| 3828 | const bool in_death_test_child_process = |
---|
| 3829 | internal::GTEST_FLAG(internal_run_death_test).length() > 0; |
---|
| 3830 | |
---|
| 3831 | // Either the user wants Google Test to catch exceptions thrown by the |
---|
| 3832 | // tests or this is executing in the context of death test child |
---|
| 3833 | // process. In either case the user does not want to see pop-up dialogs |
---|
| 3834 | // about crashes - they are expected. |
---|
| 3835 | if (impl()->catch_exceptions() || in_death_test_child_process) { |
---|
| 3836 | |
---|
| 3837 | # if !GTEST_OS_WINDOWS_MOBILE |
---|
| 3838 | // SetErrorMode doesn't exist on CE. |
---|
| 3839 | SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | |
---|
| 3840 | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); |
---|
| 3841 | # endif // !GTEST_OS_WINDOWS_MOBILE |
---|
| 3842 | |
---|
| 3843 | # if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE |
---|
| 3844 | // Death test children can be terminated with _abort(). On Windows, |
---|
| 3845 | // _abort() can show a dialog with a warning message. This forces the |
---|
| 3846 | // abort message to go to stderr instead. |
---|
| 3847 | _set_error_mode(_OUT_TO_STDERR); |
---|
| 3848 | # endif |
---|
| 3849 | |
---|
| 3850 | # if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE |
---|
| 3851 | // In the debug version, Visual Studio pops up a separate dialog |
---|
| 3852 | // offering a choice to debug the aborted program. We need to suppress |
---|
| 3853 | // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement |
---|
| 3854 | // executed. Google Test will notify the user of any unexpected |
---|
| 3855 | // failure via stderr. |
---|
| 3856 | // |
---|
| 3857 | // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. |
---|
| 3858 | // Users of prior VC versions shall suffer the agony and pain of |
---|
| 3859 | // clicking through the countless debug dialogs. |
---|
| 3860 | // TODO(vladl@google.com): find a way to suppress the abort dialog() in the |
---|
| 3861 | // debug mode when compiled with VC 7.1 or lower. |
---|
| 3862 | if (!GTEST_FLAG(break_on_failure)) |
---|
| 3863 | _set_abort_behavior( |
---|
| 3864 | 0x0, // Clear the following flags: |
---|
| 3865 | _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. |
---|
| 3866 | # endif |
---|
| 3867 | |
---|
| 3868 | } |
---|
| 3869 | #endif // GTEST_HAS_SEH |
---|
| 3870 | |
---|
| 3871 | return internal::HandleExceptionsInMethodIfSupported( |
---|
| 3872 | impl(), |
---|
| 3873 | &internal::UnitTestImpl::RunAllTests, |
---|
| 3874 | "auxiliary test code (environments or event listeners)") ? 0 : 1; |
---|
| 3875 | } |
---|
| 3876 | |
---|
| 3877 | // Returns the working directory when the first TEST() or TEST_F() was |
---|
| 3878 | // executed. |
---|
| 3879 | const char* UnitTest::original_working_dir() const { |
---|
| 3880 | return impl_->original_working_dir_.c_str(); |
---|
| 3881 | } |
---|
| 3882 | |
---|
| 3883 | // Returns the TestCase object for the test that's currently running, |
---|
| 3884 | // or NULL if no test is running. |
---|
| 3885 | // L < mutex_ |
---|
| 3886 | const TestCase* UnitTest::current_test_case() const { |
---|
| 3887 | internal::MutexLock lock(&mutex_); |
---|
| 3888 | return impl_->current_test_case(); |
---|
| 3889 | } |
---|
| 3890 | |
---|
| 3891 | // Returns the TestInfo object for the test that's currently running, |
---|
| 3892 | // or NULL if no test is running. |
---|
| 3893 | // L < mutex_ |
---|
| 3894 | const TestInfo* UnitTest::current_test_info() const { |
---|
| 3895 | internal::MutexLock lock(&mutex_); |
---|
| 3896 | return impl_->current_test_info(); |
---|
| 3897 | } |
---|
| 3898 | |
---|
| 3899 | // Returns the random seed used at the start of the current test run. |
---|
| 3900 | int UnitTest::random_seed() const { return impl_->random_seed(); } |
---|
| 3901 | |
---|
| 3902 | #if GTEST_HAS_PARAM_TEST |
---|
| 3903 | // Returns ParameterizedTestCaseRegistry object used to keep track of |
---|
| 3904 | // value-parameterized tests and instantiate and register them. |
---|
| 3905 | // L < mutex_ |
---|
| 3906 | internal::ParameterizedTestCaseRegistry& |
---|
| 3907 | UnitTest::parameterized_test_registry() { |
---|
| 3908 | return impl_->parameterized_test_registry(); |
---|
| 3909 | } |
---|
| 3910 | #endif // GTEST_HAS_PARAM_TEST |
---|
| 3911 | |
---|
| 3912 | // Creates an empty UnitTest. |
---|
| 3913 | UnitTest::UnitTest() { |
---|
| 3914 | impl_ = new internal::UnitTestImpl(this); |
---|
| 3915 | } |
---|
| 3916 | |
---|
| 3917 | // Destructor of UnitTest. |
---|
| 3918 | UnitTest::~UnitTest() { |
---|
| 3919 | delete impl_; |
---|
| 3920 | } |
---|
| 3921 | |
---|
| 3922 | // Pushes a trace defined by SCOPED_TRACE() on to the per-thread |
---|
| 3923 | // Google Test trace stack. |
---|
| 3924 | // L < mutex_ |
---|
| 3925 | void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) { |
---|
| 3926 | internal::MutexLock lock(&mutex_); |
---|
| 3927 | impl_->gtest_trace_stack().push_back(trace); |
---|
| 3928 | } |
---|
| 3929 | |
---|
| 3930 | // Pops a trace from the per-thread Google Test trace stack. |
---|
| 3931 | // L < mutex_ |
---|
| 3932 | void UnitTest::PopGTestTrace() { |
---|
| 3933 | internal::MutexLock lock(&mutex_); |
---|
| 3934 | impl_->gtest_trace_stack().pop_back(); |
---|
| 3935 | } |
---|
| 3936 | |
---|
| 3937 | namespace internal { |
---|
| 3938 | |
---|
| 3939 | UnitTestImpl::UnitTestImpl(UnitTest* parent) |
---|
| 3940 | : parent_(parent), |
---|
| 3941 | #ifdef _MSC_VER |
---|
| 3942 | # pragma warning(push) // Saves the current warning state. |
---|
| 3943 | # pragma warning(disable:4355) // Temporarily disables warning 4355 |
---|
| 3944 | // (using this in initializer). |
---|
| 3945 | default_global_test_part_result_reporter_(this), |
---|
| 3946 | default_per_thread_test_part_result_reporter_(this), |
---|
| 3947 | # pragma warning(pop) // Restores the warning state again. |
---|
| 3948 | #else |
---|
| 3949 | default_global_test_part_result_reporter_(this), |
---|
| 3950 | default_per_thread_test_part_result_reporter_(this), |
---|
| 3951 | #endif // _MSC_VER |
---|
| 3952 | global_test_part_result_repoter_( |
---|
| 3953 | &default_global_test_part_result_reporter_), |
---|
| 3954 | per_thread_test_part_result_reporter_( |
---|
| 3955 | &default_per_thread_test_part_result_reporter_), |
---|
| 3956 | #if GTEST_HAS_PARAM_TEST |
---|
| 3957 | parameterized_test_registry_(), |
---|
| 3958 | parameterized_tests_registered_(false), |
---|
| 3959 | #endif // GTEST_HAS_PARAM_TEST |
---|
| 3960 | last_death_test_case_(-1), |
---|
| 3961 | current_test_case_(NULL), |
---|
| 3962 | current_test_info_(NULL), |
---|
| 3963 | ad_hoc_test_result_(), |
---|
| 3964 | os_stack_trace_getter_(NULL), |
---|
| 3965 | post_flag_parse_init_performed_(false), |
---|
| 3966 | random_seed_(0), // Will be overridden by the flag before first use. |
---|
| 3967 | random_(0), // Will be reseeded before first use. |
---|
| 3968 | elapsed_time_(0), |
---|
| 3969 | #if GTEST_HAS_DEATH_TEST |
---|
| 3970 | internal_run_death_test_flag_(NULL), |
---|
| 3971 | death_test_factory_(new DefaultDeathTestFactory), |
---|
| 3972 | #endif |
---|
| 3973 | // Will be overridden by the flag before first use. |
---|
| 3974 | catch_exceptions_(false) { |
---|
| 3975 | listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); |
---|
| 3976 | } |
---|
| 3977 | |
---|
| 3978 | UnitTestImpl::~UnitTestImpl() { |
---|
| 3979 | // Deletes every TestCase. |
---|
| 3980 | ForEach(test_cases_, internal::Delete<TestCase>); |
---|
| 3981 | |
---|
| 3982 | // Deletes every Environment. |
---|
| 3983 | ForEach(environments_, internal::Delete<Environment>); |
---|
| 3984 | |
---|
| 3985 | delete os_stack_trace_getter_; |
---|
| 3986 | } |
---|
| 3987 | |
---|
| 3988 | #if GTEST_HAS_DEATH_TEST |
---|
| 3989 | // Disables event forwarding if the control is currently in a death test |
---|
| 3990 | // subprocess. Must not be called before InitGoogleTest. |
---|
| 3991 | void UnitTestImpl::SuppressTestEventsIfInSubprocess() { |
---|
| 3992 | if (internal_run_death_test_flag_.get() != NULL) |
---|
| 3993 | listeners()->SuppressEventForwarding(); |
---|
| 3994 | } |
---|
| 3995 | #endif // GTEST_HAS_DEATH_TEST |
---|
| 3996 | |
---|
| 3997 | // Initializes event listeners performing XML output as specified by |
---|
| 3998 | // UnitTestOptions. Must not be called before InitGoogleTest. |
---|
| 3999 | void UnitTestImpl::ConfigureXmlOutput() { |
---|
| 4000 | const String& output_format = UnitTestOptions::GetOutputFormat(); |
---|
| 4001 | if (output_format == "xml") { |
---|
| 4002 | listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( |
---|
| 4003 | UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); |
---|
| 4004 | } else if (output_format != "") { |
---|
| 4005 | printf("WARNING: unrecognized output format \"%s\" ignored.\n", |
---|
| 4006 | output_format.c_str()); |
---|
| 4007 | fflush(stdout); |
---|
| 4008 | } |
---|
| 4009 | } |
---|
| 4010 | |
---|
| 4011 | #if GTEST_CAN_STREAM_RESULTS_ |
---|
| 4012 | // Initializes event listeners for streaming test results in String form. |
---|
| 4013 | // Must not be called before InitGoogleTest. |
---|
| 4014 | void UnitTestImpl::ConfigureStreamingOutput() { |
---|
| 4015 | const string& target = GTEST_FLAG(stream_result_to); |
---|
| 4016 | if (!target.empty()) { |
---|
| 4017 | const size_t pos = target.find(':'); |
---|
| 4018 | if (pos != string::npos) { |
---|
| 4019 | listeners()->Append(new StreamingListener(target.substr(0, pos), |
---|
| 4020 | target.substr(pos+1))); |
---|
| 4021 | } else { |
---|
| 4022 | printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", |
---|
| 4023 | target.c_str()); |
---|
| 4024 | fflush(stdout); |
---|
| 4025 | } |
---|
| 4026 | } |
---|
| 4027 | } |
---|
| 4028 | #endif // GTEST_CAN_STREAM_RESULTS_ |
---|
| 4029 | |
---|
| 4030 | // Performs initialization dependent upon flag values obtained in |
---|
| 4031 | // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to |
---|
| 4032 | // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest |
---|
| 4033 | // this function is also called from RunAllTests. Since this function can be |
---|
| 4034 | // called more than once, it has to be idempotent. |
---|
| 4035 | void UnitTestImpl::PostFlagParsingInit() { |
---|
| 4036 | // Ensures that this function does not execute more than once. |
---|
| 4037 | if (!post_flag_parse_init_performed_) { |
---|
| 4038 | post_flag_parse_init_performed_ = true; |
---|
| 4039 | |
---|
| 4040 | #if GTEST_HAS_DEATH_TEST |
---|
| 4041 | InitDeathTestSubprocessControlInfo(); |
---|
| 4042 | SuppressTestEventsIfInSubprocess(); |
---|
| 4043 | #endif // GTEST_HAS_DEATH_TEST |
---|
| 4044 | |
---|
| 4045 | // Registers parameterized tests. This makes parameterized tests |
---|
| 4046 | // available to the UnitTest reflection API without running |
---|
| 4047 | // RUN_ALL_TESTS. |
---|
| 4048 | RegisterParameterizedTests(); |
---|
| 4049 | |
---|
| 4050 | // Configures listeners for XML output. This makes it possible for users |
---|
| 4051 | // to shut down the default XML output before invoking RUN_ALL_TESTS. |
---|
| 4052 | ConfigureXmlOutput(); |
---|
| 4053 | |
---|
| 4054 | #if GTEST_CAN_STREAM_RESULTS_ |
---|
| 4055 | // Configures listeners for streaming test results to the specified server. |
---|
| 4056 | ConfigureStreamingOutput(); |
---|
| 4057 | #endif // GTEST_CAN_STREAM_RESULTS_ |
---|
| 4058 | } |
---|
| 4059 | } |
---|
| 4060 | |
---|
| 4061 | // A predicate that checks the name of a TestCase against a known |
---|
| 4062 | // value. |
---|
| 4063 | // |
---|
| 4064 | // This is used for implementation of the UnitTest class only. We put |
---|
| 4065 | // it in the anonymous namespace to prevent polluting the outer |
---|
| 4066 | // namespace. |
---|
| 4067 | // |
---|
| 4068 | // TestCaseNameIs is copyable. |
---|
| 4069 | class TestCaseNameIs { |
---|
| 4070 | public: |
---|
| 4071 | // Constructor. |
---|
| 4072 | explicit TestCaseNameIs(const String& name) |
---|
| 4073 | : name_(name) {} |
---|
| 4074 | |
---|
| 4075 | // Returns true iff the name of test_case matches name_. |
---|
| 4076 | bool operator()(const TestCase* test_case) const { |
---|
| 4077 | return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; |
---|
| 4078 | } |
---|
| 4079 | |
---|
| 4080 | private: |
---|
| 4081 | String name_; |
---|
| 4082 | }; |
---|
| 4083 | |
---|
| 4084 | // Finds and returns a TestCase with the given name. If one doesn't |
---|
| 4085 | // exist, creates one and returns it. It's the CALLER'S |
---|
| 4086 | // RESPONSIBILITY to ensure that this function is only called WHEN THE |
---|
| 4087 | // TESTS ARE NOT SHUFFLED. |
---|
| 4088 | // |
---|
| 4089 | // Arguments: |
---|
| 4090 | // |
---|
| 4091 | // test_case_name: name of the test case |
---|
| 4092 | // type_param: the name of the test case's type parameter, or NULL if |
---|
| 4093 | // this is not a typed or a type-parameterized test case. |
---|
| 4094 | // set_up_tc: pointer to the function that sets up the test case |
---|
| 4095 | // tear_down_tc: pointer to the function that tears down the test case |
---|
| 4096 | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name, |
---|
| 4097 | const char* type_param, |
---|
| 4098 | Test::SetUpTestCaseFunc set_up_tc, |
---|
| 4099 | Test::TearDownTestCaseFunc tear_down_tc) { |
---|
| 4100 | // Can we find a TestCase with the given name? |
---|
| 4101 | const std::vector<TestCase*>::const_iterator test_case = |
---|
| 4102 | std::find_if(test_cases_.begin(), test_cases_.end(), |
---|
| 4103 | TestCaseNameIs(test_case_name)); |
---|
| 4104 | |
---|
| 4105 | if (test_case != test_cases_.end()) |
---|
| 4106 | return *test_case; |
---|
| 4107 | |
---|
| 4108 | // No. Let's create one. |
---|
| 4109 | TestCase* const new_test_case = |
---|
| 4110 | new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); |
---|
| 4111 | |
---|
| 4112 | // Is this a death test case? |
---|
| 4113 | if (internal::UnitTestOptions::MatchesFilter(String(test_case_name), |
---|
| 4114 | kDeathTestCaseFilter)) { |
---|
| 4115 | // Yes. Inserts the test case after the last death test case |
---|
| 4116 | // defined so far. This only works when the test cases haven't |
---|
| 4117 | // been shuffled. Otherwise we may end up running a death test |
---|
| 4118 | // after a non-death test. |
---|
| 4119 | ++last_death_test_case_; |
---|
| 4120 | test_cases_.insert(test_cases_.begin() + last_death_test_case_, |
---|
| 4121 | new_test_case); |
---|
| 4122 | } else { |
---|
| 4123 | // No. Appends to the end of the list. |
---|
| 4124 | test_cases_.push_back(new_test_case); |
---|
| 4125 | } |
---|
| 4126 | |
---|
| 4127 | test_case_indices_.push_back(static_cast<int>(test_case_indices_.size())); |
---|
| 4128 | return new_test_case; |
---|
| 4129 | } |
---|
| 4130 | |
---|
| 4131 | // Helpers for setting up / tearing down the given environment. They |
---|
| 4132 | // are for use in the ForEach() function. |
---|
| 4133 | static void SetUpEnvironment(Environment* env) { env->SetUp(); } |
---|
| 4134 | static void TearDownEnvironment(Environment* env) { env->TearDown(); } |
---|
| 4135 | |
---|
| 4136 | // Runs all tests in this UnitTest object, prints the result, and |
---|
| 4137 | // returns true if all tests are successful. If any exception is |
---|
| 4138 | // thrown during a test, the test is considered to be failed, but the |
---|
| 4139 | // rest of the tests will still be run. |
---|
| 4140 | // |
---|
| 4141 | // When parameterized tests are enabled, it expands and registers |
---|
| 4142 | // parameterized tests first in RegisterParameterizedTests(). |
---|
| 4143 | // All other functions called from RunAllTests() may safely assume that |
---|
| 4144 | // parameterized tests are ready to be counted and run. |
---|
| 4145 | bool UnitTestImpl::RunAllTests() { |
---|
| 4146 | // Makes sure InitGoogleTest() was called. |
---|
| 4147 | if (!GTestIsInitialized()) { |
---|
| 4148 | printf("%s", |
---|
| 4149 | "\nThis test program did NOT call ::testing::InitGoogleTest " |
---|
| 4150 | "before calling RUN_ALL_TESTS(). Please fix it.\n"); |
---|
| 4151 | return false; |
---|
| 4152 | } |
---|
| 4153 | |
---|
| 4154 | // Do not run any test if the --help flag was specified. |
---|
| 4155 | if (g_help_flag) |
---|
| 4156 | return true; |
---|
| 4157 | |
---|
| 4158 | // Repeats the call to the post-flag parsing initialization in case the |
---|
| 4159 | // user didn't call InitGoogleTest. |
---|
| 4160 | PostFlagParsingInit(); |
---|
| 4161 | |
---|
| 4162 | // Even if sharding is not on, test runners may want to use the |
---|
| 4163 | // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding |
---|
| 4164 | // protocol. |
---|
| 4165 | internal::WriteToShardStatusFileIfNeeded(); |
---|
| 4166 | |
---|
| 4167 | // True iff we are in a subprocess for running a thread-safe-style |
---|
| 4168 | // death test. |
---|
| 4169 | bool in_subprocess_for_death_test = false; |
---|
| 4170 | |
---|
| 4171 | #if GTEST_HAS_DEATH_TEST |
---|
| 4172 | in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); |
---|
| 4173 | #endif // GTEST_HAS_DEATH_TEST |
---|
| 4174 | |
---|
| 4175 | const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, |
---|
| 4176 | in_subprocess_for_death_test); |
---|
| 4177 | |
---|
| 4178 | // Compares the full test names with the filter to decide which |
---|
| 4179 | // tests to run. |
---|
| 4180 | const bool has_tests_to_run = FilterTests(should_shard |
---|
| 4181 | ? HONOR_SHARDING_PROTOCOL |
---|
| 4182 | : IGNORE_SHARDING_PROTOCOL) > 0; |
---|
| 4183 | |
---|
| 4184 | // Lists the tests and exits if the --gtest_list_tests flag was specified. |
---|
| 4185 | if (GTEST_FLAG(list_tests)) { |
---|
| 4186 | // This must be called *after* FilterTests() has been called. |
---|
| 4187 | ListTestsMatchingFilter(); |
---|
| 4188 | return true; |
---|
| 4189 | } |
---|
| 4190 | |
---|
| 4191 | random_seed_ = GTEST_FLAG(shuffle) ? |
---|
| 4192 | GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; |
---|
| 4193 | |
---|
| 4194 | // True iff at least one test has failed. |
---|
| 4195 | bool failed = false; |
---|
| 4196 | |
---|
| 4197 | TestEventListener* repeater = listeners()->repeater(); |
---|
| 4198 | |
---|
| 4199 | repeater->OnTestProgramStart(*parent_); |
---|
| 4200 | |
---|
| 4201 | // How many times to repeat the tests? We don't want to repeat them |
---|
| 4202 | // when we are inside the subprocess of a death test. |
---|
| 4203 | const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); |
---|
| 4204 | // Repeats forever if the repeat count is negative. |
---|
| 4205 | const bool forever = repeat < 0; |
---|
| 4206 | for (int i = 0; forever || i != repeat; i++) { |
---|
| 4207 | // We want to preserve failures generated by ad-hoc test |
---|
| 4208 | // assertions executed before RUN_ALL_TESTS(). |
---|
| 4209 | ClearNonAdHocTestResult(); |
---|
| 4210 | |
---|
| 4211 | const TimeInMillis start = GetTimeInMillis(); |
---|
| 4212 | |
---|
| 4213 | // Shuffles test cases and tests if requested. |
---|
| 4214 | if (has_tests_to_run && GTEST_FLAG(shuffle)) { |
---|
| 4215 | random()->Reseed(random_seed_); |
---|
| 4216 | // This should be done before calling OnTestIterationStart(), |
---|
| 4217 | // such that a test event listener can see the actual test order |
---|
| 4218 | // in the event. |
---|
| 4219 | ShuffleTests(); |
---|
| 4220 | } |
---|
| 4221 | |
---|
| 4222 | // Tells the unit test event listeners that the tests are about to start. |
---|
| 4223 | repeater->OnTestIterationStart(*parent_, i); |
---|
| 4224 | |
---|
| 4225 | // Runs each test case if there is at least one test to run. |
---|
| 4226 | if (has_tests_to_run) { |
---|
| 4227 | // Sets up all environments beforehand. |
---|
| 4228 | repeater->OnEnvironmentsSetUpStart(*parent_); |
---|
| 4229 | ForEach(environments_, SetUpEnvironment); |
---|
| 4230 | repeater->OnEnvironmentsSetUpEnd(*parent_); |
---|
| 4231 | |
---|
| 4232 | // Runs the tests only if there was no fatal failure during global |
---|
| 4233 | // set-up. |
---|
| 4234 | if (!Test::HasFatalFailure()) { |
---|
| 4235 | for (int test_index = 0; test_index < total_test_case_count(); |
---|
| 4236 | test_index++) { |
---|
| 4237 | GetMutableTestCase(test_index)->Run(); |
---|
| 4238 | } |
---|
| 4239 | } |
---|
| 4240 | |
---|
| 4241 | // Tears down all environments in reverse order afterwards. |
---|
| 4242 | repeater->OnEnvironmentsTearDownStart(*parent_); |
---|
| 4243 | std::for_each(environments_.rbegin(), environments_.rend(), |
---|
| 4244 | TearDownEnvironment); |
---|
| 4245 | repeater->OnEnvironmentsTearDownEnd(*parent_); |
---|
| 4246 | } |
---|
| 4247 | |
---|
| 4248 | elapsed_time_ = GetTimeInMillis() - start; |
---|
| 4249 | |
---|
| 4250 | // Tells the unit test event listener that the tests have just finished. |
---|
| 4251 | repeater->OnTestIterationEnd(*parent_, i); |
---|
| 4252 | |
---|
| 4253 | // Gets the result and clears it. |
---|
| 4254 | if (!Passed()) { |
---|
| 4255 | failed = true; |
---|
| 4256 | } |
---|
| 4257 | |
---|
| 4258 | // Restores the original test order after the iteration. This |
---|
| 4259 | // allows the user to quickly repro a failure that happens in the |
---|
| 4260 | // N-th iteration without repeating the first (N - 1) iterations. |
---|
| 4261 | // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in |
---|
| 4262 | // case the user somehow changes the value of the flag somewhere |
---|
| 4263 | // (it's always safe to unshuffle the tests). |
---|
| 4264 | UnshuffleTests(); |
---|
| 4265 | |
---|
| 4266 | if (GTEST_FLAG(shuffle)) { |
---|
| 4267 | // Picks a new random seed for each iteration. |
---|
| 4268 | random_seed_ = GetNextRandomSeed(random_seed_); |
---|
| 4269 | } |
---|
| 4270 | } |
---|
| 4271 | |
---|
| 4272 | repeater->OnTestProgramEnd(*parent_); |
---|
| 4273 | |
---|
| 4274 | return !failed; |
---|
| 4275 | } |
---|
| 4276 | |
---|
| 4277 | // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file |
---|
| 4278 | // if the variable is present. If a file already exists at this location, this |
---|
| 4279 | // function will write over it. If the variable is present, but the file cannot |
---|
| 4280 | // be created, prints an error and exits. |
---|
| 4281 | void WriteToShardStatusFileIfNeeded() { |
---|
| 4282 | const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); |
---|
| 4283 | if (test_shard_file != NULL) { |
---|
| 4284 | FILE* const file = posix::FOpen(test_shard_file, "w"); |
---|
| 4285 | if (file == NULL) { |
---|
| 4286 | ColoredPrintf(COLOR_RED, |
---|
| 4287 | "Could not write to the test shard status file \"%s\" " |
---|
| 4288 | "specified by the %s environment variable.\n", |
---|
| 4289 | test_shard_file, kTestShardStatusFile); |
---|
| 4290 | fflush(stdout); |
---|
| 4291 | exit(EXIT_FAILURE); |
---|
| 4292 | } |
---|
| 4293 | fclose(file); |
---|
| 4294 | } |
---|
| 4295 | } |
---|
| 4296 | |
---|
| 4297 | // Checks whether sharding is enabled by examining the relevant |
---|
| 4298 | // environment variable values. If the variables are present, |
---|
| 4299 | // but inconsistent (i.e., shard_index >= total_shards), prints |
---|
| 4300 | // an error and exits. If in_subprocess_for_death_test, sharding is |
---|
| 4301 | // disabled because it must only be applied to the original test |
---|
| 4302 | // process. Otherwise, we could filter out death tests we intended to execute. |
---|
| 4303 | bool ShouldShard(const char* total_shards_env, |
---|
| 4304 | const char* shard_index_env, |
---|
| 4305 | bool in_subprocess_for_death_test) { |
---|
| 4306 | if (in_subprocess_for_death_test) { |
---|
| 4307 | return false; |
---|
| 4308 | } |
---|
| 4309 | |
---|
| 4310 | const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); |
---|
| 4311 | const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); |
---|
| 4312 | |
---|
| 4313 | if (total_shards == -1 && shard_index == -1) { |
---|
| 4314 | return false; |
---|
| 4315 | } else if (total_shards == -1 && shard_index != -1) { |
---|
| 4316 | const Message msg = Message() |
---|
| 4317 | << "Invalid environment variables: you have " |
---|
| 4318 | << kTestShardIndex << " = " << shard_index |
---|
| 4319 | << ", but have left " << kTestTotalShards << " unset.\n"; |
---|
| 4320 | ColoredPrintf(COLOR_RED, msg.GetString().c_str()); |
---|
| 4321 | fflush(stdout); |
---|
| 4322 | exit(EXIT_FAILURE); |
---|
| 4323 | } else if (total_shards != -1 && shard_index == -1) { |
---|
| 4324 | const Message msg = Message() |
---|
| 4325 | << "Invalid environment variables: you have " |
---|
| 4326 | << kTestTotalShards << " = " << total_shards |
---|
| 4327 | << ", but have left " << kTestShardIndex << " unset.\n"; |
---|
| 4328 | ColoredPrintf(COLOR_RED, msg.GetString().c_str()); |
---|
| 4329 | fflush(stdout); |
---|
| 4330 | exit(EXIT_FAILURE); |
---|
| 4331 | } else if (shard_index < 0 || shard_index >= total_shards) { |
---|
| 4332 | const Message msg = Message() |
---|
| 4333 | << "Invalid environment variables: we require 0 <= " |
---|
| 4334 | << kTestShardIndex << " < " << kTestTotalShards |
---|
| 4335 | << ", but you have " << kTestShardIndex << "=" << shard_index |
---|
| 4336 | << ", " << kTestTotalShards << "=" << total_shards << ".\n"; |
---|
| 4337 | ColoredPrintf(COLOR_RED, msg.GetString().c_str()); |
---|
| 4338 | fflush(stdout); |
---|
| 4339 | exit(EXIT_FAILURE); |
---|
| 4340 | } |
---|
| 4341 | |
---|
| 4342 | return total_shards > 1; |
---|
| 4343 | } |
---|
| 4344 | |
---|
| 4345 | // Parses the environment variable var as an Int32. If it is unset, |
---|
| 4346 | // returns default_val. If it is not an Int32, prints an error |
---|
| 4347 | // and aborts. |
---|
| 4348 | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) { |
---|
| 4349 | const char* str_val = posix::GetEnv(var); |
---|
| 4350 | if (str_val == NULL) { |
---|
| 4351 | return default_val; |
---|
| 4352 | } |
---|
| 4353 | |
---|
| 4354 | Int32 result; |
---|
| 4355 | if (!ParseInt32(Message() << "The value of environment variable " << var, |
---|
| 4356 | str_val, &result)) { |
---|
| 4357 | exit(EXIT_FAILURE); |
---|
| 4358 | } |
---|
| 4359 | return result; |
---|
| 4360 | } |
---|
| 4361 | |
---|
| 4362 | // Given the total number of shards, the shard index, and the test id, |
---|
| 4363 | // returns true iff the test should be run on this shard. The test id is |
---|
| 4364 | // some arbitrary but unique non-negative integer assigned to each test |
---|
| 4365 | // method. Assumes that 0 <= shard_index < total_shards. |
---|
| 4366 | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { |
---|
| 4367 | return (test_id % total_shards) == shard_index; |
---|
| 4368 | } |
---|
| 4369 | |
---|
| 4370 | // Compares the name of each test with the user-specified filter to |
---|
| 4371 | // decide whether the test should be run, then records the result in |
---|
| 4372 | // each TestCase and TestInfo object. |
---|
| 4373 | // If shard_tests == true, further filters tests based on sharding |
---|
| 4374 | // variables in the environment - see |
---|
| 4375 | // http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. |
---|
| 4376 | // Returns the number of tests that should run. |
---|
| 4377 | int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { |
---|
| 4378 | const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? |
---|
| 4379 | Int32FromEnvOrDie(kTestTotalShards, -1) : -1; |
---|
| 4380 | const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? |
---|
| 4381 | Int32FromEnvOrDie(kTestShardIndex, -1) : -1; |
---|
| 4382 | |
---|
| 4383 | // num_runnable_tests are the number of tests that will |
---|
| 4384 | // run across all shards (i.e., match filter and are not disabled). |
---|
| 4385 | // num_selected_tests are the number of tests to be run on |
---|
| 4386 | // this shard. |
---|
| 4387 | int num_runnable_tests = 0; |
---|
| 4388 | int num_selected_tests = 0; |
---|
| 4389 | for (size_t i = 0; i < test_cases_.size(); i++) { |
---|
| 4390 | TestCase* const test_case = test_cases_[i]; |
---|
| 4391 | const String &test_case_name = test_case->name(); |
---|
| 4392 | test_case->set_should_run(false); |
---|
| 4393 | |
---|
| 4394 | for (size_t j = 0; j < test_case->test_info_list().size(); j++) { |
---|
| 4395 | TestInfo* const test_info = test_case->test_info_list()[j]; |
---|
| 4396 | const String test_name(test_info->name()); |
---|
| 4397 | // A test is disabled if test case name or test name matches |
---|
| 4398 | // kDisableTestFilter. |
---|
| 4399 | const bool is_disabled = |
---|
| 4400 | internal::UnitTestOptions::MatchesFilter(test_case_name, |
---|
| 4401 | kDisableTestFilter) || |
---|
| 4402 | internal::UnitTestOptions::MatchesFilter(test_name, |
---|
| 4403 | kDisableTestFilter); |
---|
| 4404 | test_info->is_disabled_ = is_disabled; |
---|
| 4405 | |
---|
| 4406 | const bool matches_filter = |
---|
| 4407 | internal::UnitTestOptions::FilterMatchesTest(test_case_name, |
---|
| 4408 | test_name); |
---|
| 4409 | test_info->matches_filter_ = matches_filter; |
---|
| 4410 | |
---|
| 4411 | const bool is_runnable = |
---|
| 4412 | (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && |
---|
| 4413 | matches_filter; |
---|
| 4414 | |
---|
| 4415 | const bool is_selected = is_runnable && |
---|
| 4416 | (shard_tests == IGNORE_SHARDING_PROTOCOL || |
---|
| 4417 | ShouldRunTestOnShard(total_shards, shard_index, |
---|
| 4418 | num_runnable_tests)); |
---|
| 4419 | |
---|
| 4420 | num_runnable_tests += is_runnable; |
---|
| 4421 | num_selected_tests += is_selected; |
---|
| 4422 | |
---|
| 4423 | test_info->should_run_ = is_selected; |
---|
| 4424 | test_case->set_should_run(test_case->should_run() || is_selected); |
---|
| 4425 | } |
---|
| 4426 | } |
---|
| 4427 | return num_selected_tests; |
---|
| 4428 | } |
---|
| 4429 | |
---|
| 4430 | // Prints the names of the tests matching the user-specified filter flag. |
---|
| 4431 | void UnitTestImpl::ListTestsMatchingFilter() { |
---|
| 4432 | for (size_t i = 0; i < test_cases_.size(); i++) { |
---|
| 4433 | const TestCase* const test_case = test_cases_[i]; |
---|
| 4434 | bool printed_test_case_name = false; |
---|
| 4435 | |
---|
| 4436 | for (size_t j = 0; j < test_case->test_info_list().size(); j++) { |
---|
| 4437 | const TestInfo* const test_info = |
---|
| 4438 | test_case->test_info_list()[j]; |
---|
| 4439 | if (test_info->matches_filter_) { |
---|
| 4440 | if (!printed_test_case_name) { |
---|
| 4441 | printed_test_case_name = true; |
---|
| 4442 | printf("%s.\n", test_case->name()); |
---|
| 4443 | } |
---|
| 4444 | printf(" %s\n", test_info->name()); |
---|
| 4445 | } |
---|
| 4446 | } |
---|
| 4447 | } |
---|
| 4448 | fflush(stdout); |
---|
| 4449 | } |
---|
| 4450 | |
---|
| 4451 | // Sets the OS stack trace getter. |
---|
| 4452 | // |
---|
| 4453 | // Does nothing if the input and the current OS stack trace getter are |
---|
| 4454 | // the same; otherwise, deletes the old getter and makes the input the |
---|
| 4455 | // current getter. |
---|
| 4456 | void UnitTestImpl::set_os_stack_trace_getter( |
---|
| 4457 | OsStackTraceGetterInterface* getter) { |
---|
| 4458 | if (os_stack_trace_getter_ != getter) { |
---|
| 4459 | delete os_stack_trace_getter_; |
---|
| 4460 | os_stack_trace_getter_ = getter; |
---|
| 4461 | } |
---|
| 4462 | } |
---|
| 4463 | |
---|
| 4464 | // Returns the current OS stack trace getter if it is not NULL; |
---|
| 4465 | // otherwise, creates an OsStackTraceGetter, makes it the current |
---|
| 4466 | // getter, and returns it. |
---|
| 4467 | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { |
---|
| 4468 | if (os_stack_trace_getter_ == NULL) { |
---|
| 4469 | os_stack_trace_getter_ = new OsStackTraceGetter; |
---|
| 4470 | } |
---|
| 4471 | |
---|
| 4472 | return os_stack_trace_getter_; |
---|
| 4473 | } |
---|
| 4474 | |
---|
| 4475 | // Returns the TestResult for the test that's currently running, or |
---|
| 4476 | // the TestResult for the ad hoc test if no test is running. |
---|
| 4477 | TestResult* UnitTestImpl::current_test_result() { |
---|
| 4478 | return current_test_info_ ? |
---|
| 4479 | &(current_test_info_->result_) : &ad_hoc_test_result_; |
---|
| 4480 | } |
---|
| 4481 | |
---|
| 4482 | // Shuffles all test cases, and the tests within each test case, |
---|
| 4483 | // making sure that death tests are still run first. |
---|
| 4484 | void UnitTestImpl::ShuffleTests() { |
---|
| 4485 | // Shuffles the death test cases. |
---|
| 4486 | ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); |
---|
| 4487 | |
---|
| 4488 | // Shuffles the non-death test cases. |
---|
| 4489 | ShuffleRange(random(), last_death_test_case_ + 1, |
---|
| 4490 | static_cast<int>(test_cases_.size()), &test_case_indices_); |
---|
| 4491 | |
---|
| 4492 | // Shuffles the tests inside each test case. |
---|
| 4493 | for (size_t i = 0; i < test_cases_.size(); i++) { |
---|
| 4494 | test_cases_[i]->ShuffleTests(random()); |
---|
| 4495 | } |
---|
| 4496 | } |
---|
| 4497 | |
---|
| 4498 | // Restores the test cases and tests to their order before the first shuffle. |
---|
| 4499 | void UnitTestImpl::UnshuffleTests() { |
---|
| 4500 | for (size_t i = 0; i < test_cases_.size(); i++) { |
---|
| 4501 | // Unshuffles the tests in each test case. |
---|
| 4502 | test_cases_[i]->UnshuffleTests(); |
---|
| 4503 | // Resets the index of each test case. |
---|
| 4504 | test_case_indices_[i] = static_cast<int>(i); |
---|
| 4505 | } |
---|
| 4506 | } |
---|
| 4507 | |
---|
| 4508 | // Returns the current OS stack trace as a String. |
---|
| 4509 | // |
---|
| 4510 | // The maximum number of stack frames to be included is specified by |
---|
| 4511 | // the gtest_stack_trace_depth flag. The skip_count parameter |
---|
| 4512 | // specifies the number of top frames to be skipped, which doesn't |
---|
| 4513 | // count against the number of frames to be included. |
---|
| 4514 | // |
---|
| 4515 | // For example, if Foo() calls Bar(), which in turn calls |
---|
| 4516 | // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in |
---|
| 4517 | // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. |
---|
| 4518 | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, |
---|
| 4519 | int skip_count) { |
---|
| 4520 | // We pass skip_count + 1 to skip this wrapper function in addition |
---|
| 4521 | // to what the user really wants to skip. |
---|
| 4522 | return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); |
---|
| 4523 | } |
---|
| 4524 | |
---|
| 4525 | // Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to |
---|
| 4526 | // suppress unreachable code warnings. |
---|
| 4527 | namespace { |
---|
| 4528 | class ClassUniqueToAlwaysTrue {}; |
---|
| 4529 | } |
---|
| 4530 | |
---|
| 4531 | bool IsTrue(bool condition) { return condition; } |
---|
| 4532 | |
---|
| 4533 | bool AlwaysTrue() { |
---|
| 4534 | #if GTEST_HAS_EXCEPTIONS |
---|
| 4535 | // This condition is always false so AlwaysTrue() never actually throws, |
---|
| 4536 | // but it makes the compiler think that it may throw. |
---|
| 4537 | if (IsTrue(false)) |
---|
| 4538 | throw ClassUniqueToAlwaysTrue(); |
---|
| 4539 | #endif // GTEST_HAS_EXCEPTIONS |
---|
| 4540 | return true; |
---|
| 4541 | } |
---|
| 4542 | |
---|
| 4543 | // If *pstr starts with the given prefix, modifies *pstr to be right |
---|
| 4544 | // past the prefix and returns true; otherwise leaves *pstr unchanged |
---|
| 4545 | // and returns false. None of pstr, *pstr, and prefix can be NULL. |
---|
| 4546 | bool SkipPrefix(const char* prefix, const char** pstr) { |
---|
| 4547 | const size_t prefix_len = strlen(prefix); |
---|
| 4548 | if (strncmp(*pstr, prefix, prefix_len) == 0) { |
---|
| 4549 | *pstr += prefix_len; |
---|
| 4550 | return true; |
---|
| 4551 | } |
---|
| 4552 | return false; |
---|
| 4553 | } |
---|
| 4554 | |
---|
| 4555 | // Parses a string as a command line flag. The string should have |
---|
| 4556 | // the format "--flag=value". When def_optional is true, the "=value" |
---|
| 4557 | // part can be omitted. |
---|
| 4558 | // |
---|
| 4559 | // Returns the value of the flag, or NULL if the parsing failed. |
---|
| 4560 | const char* ParseFlagValue(const char* str, |
---|
| 4561 | const char* flag, |
---|
| 4562 | bool def_optional) { |
---|
| 4563 | // str and flag must not be NULL. |
---|
| 4564 | if (str == NULL || flag == NULL) return NULL; |
---|
| 4565 | |
---|
| 4566 | // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. |
---|
| 4567 | const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX_, flag); |
---|
| 4568 | const size_t flag_len = flag_str.length(); |
---|
| 4569 | if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; |
---|
| 4570 | |
---|
| 4571 | // Skips the flag name. |
---|
| 4572 | const char* flag_end = str + flag_len; |
---|
| 4573 | |
---|
| 4574 | // When def_optional is true, it's OK to not have a "=value" part. |
---|
| 4575 | if (def_optional && (flag_end[0] == '\0')) { |
---|
| 4576 | return flag_end; |
---|
| 4577 | } |
---|
| 4578 | |
---|
| 4579 | // If def_optional is true and there are more characters after the |
---|
| 4580 | // flag name, or if def_optional is false, there must be a '=' after |
---|
| 4581 | // the flag name. |
---|
| 4582 | if (flag_end[0] != '=') return NULL; |
---|
| 4583 | |
---|
| 4584 | // Returns the string after "=". |
---|
| 4585 | return flag_end + 1; |
---|
| 4586 | } |
---|
| 4587 | |
---|
| 4588 | // Parses a string for a bool flag, in the form of either |
---|
| 4589 | // "--flag=value" or "--flag". |
---|
| 4590 | // |
---|
| 4591 | // In the former case, the value is taken as true as long as it does |
---|
| 4592 | // not start with '0', 'f', or 'F'. |
---|
| 4593 | // |
---|
| 4594 | // In the latter case, the value is taken as true. |
---|
| 4595 | // |
---|
| 4596 | // On success, stores the value of the flag in *value, and returns |
---|
| 4597 | // true. On failure, returns false without changing *value. |
---|
| 4598 | bool ParseBoolFlag(const char* str, const char* flag, bool* value) { |
---|
| 4599 | // Gets the value of the flag as a string. |
---|
| 4600 | const char* const value_str = ParseFlagValue(str, flag, true); |
---|
| 4601 | |
---|
| 4602 | // Aborts if the parsing failed. |
---|
| 4603 | if (value_str == NULL) return false; |
---|
| 4604 | |
---|
| 4605 | // Converts the string value to a bool. |
---|
| 4606 | *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); |
---|
| 4607 | return true; |
---|
| 4608 | } |
---|
| 4609 | |
---|
| 4610 | // Parses a string for an Int32 flag, in the form of |
---|
| 4611 | // "--flag=value". |
---|
| 4612 | // |
---|
| 4613 | // On success, stores the value of the flag in *value, and returns |
---|
| 4614 | // true. On failure, returns false without changing *value. |
---|
| 4615 | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) { |
---|
| 4616 | // Gets the value of the flag as a string. |
---|
| 4617 | const char* const value_str = ParseFlagValue(str, flag, false); |
---|
| 4618 | |
---|
| 4619 | // Aborts if the parsing failed. |
---|
| 4620 | if (value_str == NULL) return false; |
---|
| 4621 | |
---|
| 4622 | // Sets *value to the value of the flag. |
---|
| 4623 | return ParseInt32(Message() << "The value of flag --" << flag, |
---|
| 4624 | value_str, value); |
---|
| 4625 | } |
---|
| 4626 | |
---|
| 4627 | // Parses a string for a string flag, in the form of |
---|
| 4628 | // "--flag=value". |
---|
| 4629 | // |
---|
| 4630 | // On success, stores the value of the flag in *value, and returns |
---|
| 4631 | // true. On failure, returns false without changing *value. |
---|
| 4632 | bool ParseStringFlag(const char* str, const char* flag, String* value) { |
---|
| 4633 | // Gets the value of the flag as a string. |
---|
| 4634 | const char* const value_str = ParseFlagValue(str, flag, false); |
---|
| 4635 | |
---|
| 4636 | // Aborts if the parsing failed. |
---|
| 4637 | if (value_str == NULL) return false; |
---|
| 4638 | |
---|
| 4639 | // Sets *value to the value of the flag. |
---|
| 4640 | *value = value_str; |
---|
| 4641 | return true; |
---|
| 4642 | } |
---|
| 4643 | |
---|
| 4644 | // Determines whether a string has a prefix that Google Test uses for its |
---|
| 4645 | // flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. |
---|
| 4646 | // If Google Test detects that a command line flag has its prefix but is not |
---|
| 4647 | // recognized, it will print its help message. Flags starting with |
---|
| 4648 | // GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test |
---|
| 4649 | // internal flags and do not trigger the help message. |
---|
| 4650 | static bool HasGoogleTestFlagPrefix(const char* str) { |
---|
| 4651 | return (SkipPrefix("--", &str) || |
---|
| 4652 | SkipPrefix("-", &str) || |
---|
| 4653 | SkipPrefix("/", &str)) && |
---|
| 4654 | !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && |
---|
| 4655 | (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || |
---|
| 4656 | SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); |
---|
| 4657 | } |
---|
| 4658 | |
---|
| 4659 | // Prints a string containing code-encoded text. The following escape |
---|
| 4660 | // sequences can be used in the string to control the text color: |
---|
| 4661 | // |
---|
| 4662 | // @@ prints a single '@' character. |
---|
| 4663 | // @R changes the color to red. |
---|
| 4664 | // @G changes the color to green. |
---|
| 4665 | // @Y changes the color to yellow. |
---|
| 4666 | // @D changes to the default terminal text color. |
---|
| 4667 | // |
---|
| 4668 | // TODO(wan@google.com): Write tests for this once we add stdout |
---|
| 4669 | // capturing to Google Test. |
---|
| 4670 | static void PrintColorEncoded(const char* str) { |
---|
| 4671 | GTestColor color = COLOR_DEFAULT; // The current color. |
---|
| 4672 | |
---|
| 4673 | // Conceptually, we split the string into segments divided by escape |
---|
| 4674 | // sequences. Then we print one segment at a time. At the end of |
---|
| 4675 | // each iteration, the str pointer advances to the beginning of the |
---|
| 4676 | // next segment. |
---|
| 4677 | for (;;) { |
---|
| 4678 | const char* p = strchr(str, '@'); |
---|
| 4679 | if (p == NULL) { |
---|
| 4680 | ColoredPrintf(color, "%s", str); |
---|
| 4681 | return; |
---|
| 4682 | } |
---|
| 4683 | |
---|
| 4684 | ColoredPrintf(color, "%s", String(str, p - str).c_str()); |
---|
| 4685 | |
---|
| 4686 | const char ch = p[1]; |
---|
| 4687 | str = p + 2; |
---|
| 4688 | if (ch == '@') { |
---|
| 4689 | ColoredPrintf(color, "@"); |
---|
| 4690 | } else if (ch == 'D') { |
---|
| 4691 | color = COLOR_DEFAULT; |
---|
| 4692 | } else if (ch == 'R') { |
---|
| 4693 | color = COLOR_RED; |
---|
| 4694 | } else if (ch == 'G') { |
---|
| 4695 | color = COLOR_GREEN; |
---|
| 4696 | } else if (ch == 'Y') { |
---|
| 4697 | color = COLOR_YELLOW; |
---|
| 4698 | } else { |
---|
| 4699 | --str; |
---|
| 4700 | } |
---|
| 4701 | } |
---|
| 4702 | } |
---|
| 4703 | |
---|
| 4704 | static const char kColorEncodedHelpMessage[] = |
---|
| 4705 | "This program contains tests written using " GTEST_NAME_ ". You can use the\n" |
---|
| 4706 | "following command line flags to control its behavior:\n" |
---|
| 4707 | "\n" |
---|
| 4708 | "Test Selection:\n" |
---|
| 4709 | " @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" |
---|
| 4710 | " List the names of all tests instead of running them. The name of\n" |
---|
| 4711 | " TEST(Foo, Bar) is \"Foo.Bar\".\n" |
---|
| 4712 | " @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" |
---|
| 4713 | "[@G-@YNEGATIVE_PATTERNS]@D\n" |
---|
| 4714 | " Run only the tests whose name matches one of the positive patterns but\n" |
---|
| 4715 | " none of the negative patterns. '?' matches any single character; '*'\n" |
---|
| 4716 | " matches any substring; ':' separates two patterns.\n" |
---|
| 4717 | " @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" |
---|
| 4718 | " Run all disabled tests too.\n" |
---|
| 4719 | "\n" |
---|
| 4720 | "Test Execution:\n" |
---|
| 4721 | " @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" |
---|
| 4722 | " Run the tests repeatedly; use a negative count to repeat forever.\n" |
---|
| 4723 | " @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" |
---|
| 4724 | " Randomize tests' orders on every iteration.\n" |
---|
| 4725 | " @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" |
---|
| 4726 | " Random number seed to use for shuffling test orders (between 1 and\n" |
---|
| 4727 | " 99999, or 0 to use a seed based on the current time).\n" |
---|
| 4728 | "\n" |
---|
| 4729 | "Test Output:\n" |
---|
| 4730 | " @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" |
---|
| 4731 | " Enable/disable colored output. The default is @Gauto@D.\n" |
---|
| 4732 | " -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" |
---|
| 4733 | " Don't print the elapsed time of each test.\n" |
---|
| 4734 | " @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" |
---|
| 4735 | GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" |
---|
| 4736 | " Generate an XML report in the given directory or with the given file\n" |
---|
| 4737 | " name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" |
---|
| 4738 | #if GTEST_CAN_STREAM_RESULTS_ |
---|
| 4739 | " @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" |
---|
| 4740 | " Stream test results to the given server.\n" |
---|
| 4741 | #endif // GTEST_CAN_STREAM_RESULTS_ |
---|
| 4742 | "\n" |
---|
| 4743 | "Assertion Behavior:\n" |
---|
| 4744 | #if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS |
---|
| 4745 | " @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" |
---|
| 4746 | " Set the default death test style.\n" |
---|
| 4747 | #endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS |
---|
| 4748 | " @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" |
---|
| 4749 | " Turn assertion failures into debugger break-points.\n" |
---|
| 4750 | " @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" |
---|
| 4751 | " Turn assertion failures into C++ exceptions.\n" |
---|
| 4752 | " @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" |
---|
| 4753 | " Do not report exceptions as test failures. Instead, allow them\n" |
---|
| 4754 | " to crash the program or throw a pop-up (on Windows).\n" |
---|
| 4755 | "\n" |
---|
| 4756 | "Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " |
---|
| 4757 | "the corresponding\n" |
---|
| 4758 | "environment variable of a flag (all letters in upper-case). For example, to\n" |
---|
| 4759 | "disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ |
---|
| 4760 | "color=no@D or set\n" |
---|
| 4761 | "the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" |
---|
| 4762 | "\n" |
---|
| 4763 | "For more information, please read the " GTEST_NAME_ " documentation at\n" |
---|
| 4764 | "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" |
---|
| 4765 | "(not one in your own code or tests), please report it to\n" |
---|
| 4766 | "@G<" GTEST_DEV_EMAIL_ ">@D.\n"; |
---|
| 4767 | |
---|
| 4768 | // Parses the command line for Google Test flags, without initializing |
---|
| 4769 | // other parts of Google Test. The type parameter CharType can be |
---|
| 4770 | // instantiated to either char or wchar_t. |
---|
| 4771 | template <typename CharType> |
---|
| 4772 | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { |
---|
| 4773 | for (int i = 1; i < *argc; i++) { |
---|
| 4774 | const String arg_string = StreamableToString(argv[i]); |
---|
| 4775 | const char* const arg = arg_string.c_str(); |
---|
| 4776 | |
---|
| 4777 | using internal::ParseBoolFlag; |
---|
| 4778 | using internal::ParseInt32Flag; |
---|
| 4779 | using internal::ParseStringFlag; |
---|
| 4780 | |
---|
| 4781 | // Do we see a Google Test flag? |
---|
| 4782 | if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, |
---|
| 4783 | >EST_FLAG(also_run_disabled_tests)) || |
---|
| 4784 | ParseBoolFlag(arg, kBreakOnFailureFlag, |
---|
| 4785 | >EST_FLAG(break_on_failure)) || |
---|
| 4786 | ParseBoolFlag(arg, kCatchExceptionsFlag, |
---|
| 4787 | >EST_FLAG(catch_exceptions)) || |
---|
| 4788 | ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || |
---|
| 4789 | ParseStringFlag(arg, kDeathTestStyleFlag, |
---|
| 4790 | >EST_FLAG(death_test_style)) || |
---|
| 4791 | ParseBoolFlag(arg, kDeathTestUseFork, |
---|
| 4792 | >EST_FLAG(death_test_use_fork)) || |
---|
| 4793 | ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || |
---|
| 4794 | ParseStringFlag(arg, kInternalRunDeathTestFlag, |
---|
| 4795 | >EST_FLAG(internal_run_death_test)) || |
---|
| 4796 | ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || |
---|
| 4797 | ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || |
---|
| 4798 | ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || |
---|
| 4799 | ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || |
---|
| 4800 | ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || |
---|
| 4801 | ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || |
---|
| 4802 | ParseInt32Flag(arg, kStackTraceDepthFlag, |
---|
| 4803 | >EST_FLAG(stack_trace_depth)) || |
---|
| 4804 | ParseStringFlag(arg, kStreamResultToFlag, |
---|
| 4805 | >EST_FLAG(stream_result_to)) || |
---|
| 4806 | ParseBoolFlag(arg, kThrowOnFailureFlag, |
---|
| 4807 | >EST_FLAG(throw_on_failure)) |
---|
| 4808 | ) { |
---|
| 4809 | // Yes. Shift the remainder of the argv list left by one. Note |
---|
| 4810 | // that argv has (*argc + 1) elements, the last one always being |
---|
| 4811 | // NULL. The following loop moves the trailing NULL element as |
---|
| 4812 | // well. |
---|
| 4813 | for (int j = i; j != *argc; j++) { |
---|
| 4814 | argv[j] = argv[j + 1]; |
---|
| 4815 | } |
---|
| 4816 | |
---|
| 4817 | // Decrements the argument count. |
---|
| 4818 | (*argc)--; |
---|
| 4819 | |
---|
| 4820 | // We also need to decrement the iterator as we just removed |
---|
| 4821 | // an element. |
---|
| 4822 | i--; |
---|
| 4823 | } else if (arg_string == "--help" || arg_string == "-h" || |
---|
| 4824 | arg_string == "-?" || arg_string == "/?" || |
---|
| 4825 | HasGoogleTestFlagPrefix(arg)) { |
---|
| 4826 | // Both help flag and unrecognized Google Test flags (excluding |
---|
| 4827 | // internal ones) trigger help display. |
---|
| 4828 | g_help_flag = true; |
---|
| 4829 | } |
---|
| 4830 | } |
---|
| 4831 | |
---|
| 4832 | if (g_help_flag) { |
---|
| 4833 | // We print the help here instead of in RUN_ALL_TESTS(), as the |
---|
| 4834 | // latter may not be called at all if the user is using Google |
---|
| 4835 | // Test with another testing framework. |
---|
| 4836 | PrintColorEncoded(kColorEncodedHelpMessage); |
---|
| 4837 | } |
---|
| 4838 | } |
---|
| 4839 | |
---|
| 4840 | // Parses the command line for Google Test flags, without initializing |
---|
| 4841 | // other parts of Google Test. |
---|
| 4842 | void ParseGoogleTestFlagsOnly(int* argc, char** argv) { |
---|
| 4843 | ParseGoogleTestFlagsOnlyImpl(argc, argv); |
---|
| 4844 | } |
---|
| 4845 | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { |
---|
| 4846 | ParseGoogleTestFlagsOnlyImpl(argc, argv); |
---|
| 4847 | } |
---|
| 4848 | |
---|
| 4849 | // The internal implementation of InitGoogleTest(). |
---|
| 4850 | // |
---|
| 4851 | // The type parameter CharType can be instantiated to either char or |
---|
| 4852 | // wchar_t. |
---|
| 4853 | template <typename CharType> |
---|
| 4854 | void InitGoogleTestImpl(int* argc, CharType** argv) { |
---|
| 4855 | g_init_gtest_count++; |
---|
| 4856 | |
---|
| 4857 | // We don't want to run the initialization code twice. |
---|
| 4858 | if (g_init_gtest_count != 1) return; |
---|
| 4859 | |
---|
| 4860 | if (*argc <= 0) return; |
---|
| 4861 | |
---|
| 4862 | internal::g_executable_path = internal::StreamableToString(argv[0]); |
---|
| 4863 | |
---|
| 4864 | #if GTEST_HAS_DEATH_TEST |
---|
| 4865 | |
---|
| 4866 | g_argvs.clear(); |
---|
| 4867 | for (int i = 0; i != *argc; i++) { |
---|
| 4868 | g_argvs.push_back(StreamableToString(argv[i])); |
---|
| 4869 | } |
---|
| 4870 | |
---|
| 4871 | #endif // GTEST_HAS_DEATH_TEST |
---|
| 4872 | |
---|
| 4873 | ParseGoogleTestFlagsOnly(argc, argv); |
---|
| 4874 | GetUnitTestImpl()->PostFlagParsingInit(); |
---|
| 4875 | } |
---|
| 4876 | |
---|
| 4877 | } // namespace internal |
---|
| 4878 | |
---|
| 4879 | // Initializes Google Test. This must be called before calling |
---|
| 4880 | // RUN_ALL_TESTS(). In particular, it parses a command line for the |
---|
| 4881 | // flags that Google Test recognizes. Whenever a Google Test flag is |
---|
| 4882 | // seen, it is removed from argv, and *argc is decremented. |
---|
| 4883 | // |
---|
| 4884 | // No value is returned. Instead, the Google Test flag variables are |
---|
| 4885 | // updated. |
---|
| 4886 | // |
---|
| 4887 | // Calling the function for the second time has no user-visible effect. |
---|
| 4888 | void InitGoogleTest(int* argc, char** argv) { |
---|
| 4889 | internal::InitGoogleTestImpl(argc, argv); |
---|
| 4890 | } |
---|
| 4891 | |
---|
| 4892 | // This overloaded version can be used in Windows programs compiled in |
---|
| 4893 | // UNICODE mode. |
---|
| 4894 | void InitGoogleTest(int* argc, wchar_t** argv) { |
---|
| 4895 | internal::InitGoogleTestImpl(argc, argv); |
---|
| 4896 | } |
---|
| 4897 | |
---|
| 4898 | } // namespace testing |
---|