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