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