1fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Copyright 2005, Google Inc. 2fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// All rights reserved. 3fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Redistribution and use in source and binary forms, with or without 5fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// modification, are permitted provided that the following conditions are 6fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// met: 7fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 8fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// * Redistributions of source code must retain the above copyright 9fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// notice, this list of conditions and the following disclaimer. 10fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// * Redistributions in binary form must reproduce the above 11fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// copyright notice, this list of conditions and the following disclaimer 12fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// in the documentation and/or other materials provided with the 13fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// distribution. 14fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// * Neither the name of Google Inc. nor the names of its 15fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// contributors may be used to endorse or promote products derived from 16fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// this software without specific prior written permission. 17fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 18fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 30fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Author: wan@google.com (Zhanyong Wan) 31fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 32fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The Google C++ Testing Framework (Google Test) 33fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 34fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include "gtest/gtest.h" 35fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include "gtest/gtest-spi.h" 36fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 37fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <ctype.h> 38fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <math.h> 39fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <stdarg.h> 40fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <stdio.h> 41fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <stdlib.h> 4236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#include <time.h> 43fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <wchar.h> 44fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <wctype.h> 45fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 46fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <algorithm> 4736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#include <iomanip> 4836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#include <limits> 49fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <ostream> // NOLINT 50fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <sstream> 51fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include <vector> 52fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 53fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_LINUX 54fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 55fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(kenton@google.com): Use autoconf to detect availability of 56fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// gettimeofday(). 57fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# define GTEST_HAS_GETTIMEOFDAY_ 1 58fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 59fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <fcntl.h> // NOLINT 60fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <limits.h> // NOLINT 61fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sched.h> // NOLINT 62fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Declares vsnprintf(). This header is not available on Windows. 63fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <strings.h> // NOLINT 64fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/mman.h> // NOLINT 65fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/time.h> // NOLINT 66fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <unistd.h> // NOLINT 67fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <string> 68fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 69fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_OS_SYMBIAN 70fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# define GTEST_HAS_GETTIMEOFDAY_ 1 71fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/time.h> // NOLINT 72fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 73fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_OS_ZOS 74fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# define GTEST_HAS_GETTIMEOFDAY_ 1 75fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/time.h> // NOLINT 76fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 77fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// On z/OS we additionally need strings.h for strcasecmp. 78fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <strings.h> // NOLINT 79fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 80fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. 81fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 82fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <windows.h> // NOLINT 83fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 84fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_OS_WINDOWS // We are on Windows proper. 85fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 86fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <io.h> // NOLINT 87fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/timeb.h> // NOLINT 88fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/types.h> // NOLINT 89fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/stat.h> // NOLINT 90fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 91fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# if GTEST_OS_WINDOWS_MINGW 92fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// MinGW has gettimeofday() but not _ftime64(). 93fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(kenton@google.com): Use autoconf to detect availability of 94fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// gettimeofday(). 95fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(kenton@google.com): There are other ways to get the time on 96fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW 97fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// supports these. consider using them instead. 98fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# define GTEST_HAS_GETTIMEOFDAY_ 1 99fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/time.h> // NOLINT 100fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# endif // GTEST_OS_WINDOWS_MINGW 101fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 102fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// cpplint thinks that the header is already included, so we want to 103fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// silence it. 104fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <windows.h> // NOLINT 105fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 106fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 107fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 108fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Assume other platforms have gettimeofday(). 109fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(kenton@google.com): Use autoconf to detect availability of 110fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// gettimeofday(). 111fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# define GTEST_HAS_GETTIMEOFDAY_ 1 112fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 113fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// cpplint thinks that the header is already included, so we want to 114fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// silence it. 115fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <sys/time.h> // NOLINT 116fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <unistd.h> // NOLINT 117fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 118fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_LINUX 119fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 120fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_EXCEPTIONS 121fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <stdexcept> 122fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 123fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 124fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_CAN_STREAM_RESULTS_ 125fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <arpa/inet.h> // NOLINT 126fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# include <netdb.h> // NOLINT 127fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 128fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 129fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Indicates that this translation unit is part of Google Test's 130fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// implementation. It must come before gtest-internal-inl.h is 131fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// included, or there will be a compiler error. This trick is to 132fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// prevent a user from accidentally including gtest-internal-inl.h in 133fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// his code. 134fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#define GTEST_IMPLEMENTATION_ 1 135fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#include "src/gtest-internal-inl.h" 136fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#undef GTEST_IMPLEMENTATION_ 137fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 138fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS 139fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# define vsnprintf _vsnprintf 140fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS 141fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 142fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace testing { 143fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 144fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtusing internal::CountIf; 145fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtusing internal::ForEach; 146fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtusing internal::GetElementOr; 147fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtusing internal::Shuffle; 148fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 149fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Constants. 150fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 151fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A test whose test case name or test name matches this filter is 152fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// disabled and not run. 153fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; 154fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 155fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A test case whose name matches this filter is considered a death 156fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// test case and will be run before test cases whose name doesn't 157fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// match this filter. 158fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"; 159fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 160fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A test filter that matches everything. 161fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kUniversalFilter[] = "*"; 162fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 163fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The default output file for XML output. 164fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kDefaultOutputFile[] = "test_detail.xml"; 165fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 166fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The environment variable name for the test shard index. 167fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kTestShardIndex[] = "GTEST_SHARD_INDEX"; 168fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The environment variable name for the total number of test shards. 169fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS"; 170fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The environment variable name for the test shard status file. 171fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"; 172fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 173fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 174fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 175fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The text used in failure messages to indicate the start of the 176fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// stack trace. 177fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst char kStackTraceMarker[] = "\nStack trace:\n"; 178fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 179fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// g_help_flag is true iff the --help flag or an equivalent form is 180fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// specified on the command line. 181fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool g_help_flag = false; 182fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 183fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 184fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 18536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic const char* GetDefaultFilter() { 18636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return kUniversalFilter; 18736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 18836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 189fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 190fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt also_run_disabled_tests, 191fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::BoolFromGTestEnv("also_run_disabled_tests", false), 192fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Run disabled tests too, in addition to the tests normally being run."); 193fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 194fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 195fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt break_on_failure, 196fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::BoolFromGTestEnv("break_on_failure", false), 197fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "True iff a failed assertion should be a debugger break-point."); 198fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 199fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 200fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt catch_exceptions, 201fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::BoolFromGTestEnv("catch_exceptions", true), 202fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "True iff " GTEST_NAME_ 203fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt " should catch exceptions and treat them as test failures."); 204fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 205fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_string_( 206fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt color, 207fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StringFromGTestEnv("color", "auto"), 208fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Whether to use colors in the output. Valid values: yes, no, " 209fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "and auto. 'auto' means to use colors if the output is " 210fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "being sent to a terminal and the TERM environment variable " 21136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "is set to a terminal type that supports colors."); 212fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 213fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_string_( 214fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt filter, 21536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee internal::StringFromGTestEnv("filter", GetDefaultFilter()), 216fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "A colon-separated list of glob (not regex) patterns " 217fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "for filtering the tests to run, optionally followed by a " 218fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "'-' and a : separated list of negative patterns (tests to " 219fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "exclude). A test is run if it matches one of the positive " 220fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "patterns and does not match any of the negative patterns."); 221fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 222fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_(list_tests, false, 223fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "List all tests without running them."); 224fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 225fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_string_( 226fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output, 227fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StringFromGTestEnv("output", ""), 228fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "A format (currently must be \"xml\"), optionally followed " 229fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "by a colon and an output file name or directory. A directory " 230fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "is indicated by a trailing pathname separator. " 231fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " 232fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "If a directory is specified, output files will be created " 233fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "within that directory, with file-names based on the test " 234fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "executable's name and, if necessary, made unique by adding " 235fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "digits."); 236fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 237fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 238fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt print_time, 239fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::BoolFromGTestEnv("print_time", true), 240fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "True iff " GTEST_NAME_ 241fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt " should display elapsed time in text output."); 242fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 243fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_int32_( 244fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt random_seed, 245fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::Int32FromGTestEnv("random_seed", 0), 246fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Random number seed to use when shuffling test orders. Must be in range " 247fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "[1, 99999], or 0 to use a seed based on the current time."); 248fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 249fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_int32_( 250fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeat, 251fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::Int32FromGTestEnv("repeat", 1), 252fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "How many times to repeat each test. Specify a negative number " 253fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "for repeating forever. Useful for shaking out flaky tests."); 254fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 255fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 256fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt show_internal_stack_frames, false, 257fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "True iff " GTEST_NAME_ " should include internal stack frames when " 258fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "printing test failure stack traces."); 259fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 260fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 261fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt shuffle, 262fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::BoolFromGTestEnv("shuffle", false), 263fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "True iff " GTEST_NAME_ 264fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt " should randomize tests' order on every run."); 265fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 266fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_int32_( 267fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt stack_trace_depth, 268fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), 269fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "The maximum number of stack frames to print when an " 270fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "assertion fails. The valid range is 0 through 100, inclusive."); 271fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 272fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_string_( 273fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt stream_result_to, 274fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StringFromGTestEnv("stream_result_to", ""), 275fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "This flag specifies the host name and the port number on which to stream " 276fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "test results. Example: \"localhost:555\". The flag is effective only on " 277fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Linux."); 278fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 279fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_DEFINE_bool_( 280fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt throw_on_failure, 281fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::BoolFromGTestEnv("throw_on_failure", false), 282fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "When this flag is specified, a failed assertion will throw an exception " 283fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "if exceptions are enabled or exit the program with a non-zero code " 284fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "otherwise."); 285fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 286fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 287fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 288fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Generates a random number from [0, range), using a Linear 289fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Congruential Generator (LCG). Crashes if 'range' is 0 or greater 290fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// than kMaxRange. 291fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUInt32 Random::Generate(UInt32 range) { 292fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // These constants are the same as are used in glibc's rand(3). 293fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt state_ = (1103515245U*state_ + 12345U) % kMaxRange; 294fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 295fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_CHECK_(range > 0) 296fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Cannot generate a number in the range [0, 0)."; 297fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_CHECK_(range <= kMaxRange) 298fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Generation of a number in [0, " << range << ") was requested, " 299fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "but this can only generate numbers in [0, " << kMaxRange << ")."; 300fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 301fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Converting via modulus introduces a bit of downward bias, but 302fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // it's simple, and a linear congruential generator isn't too good 303fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // to begin with. 304fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return state_ % range; 305fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 306fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 307fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// GTestIsInitialized() returns true iff the user has initialized 308fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Google Test. Useful for catching the user mistake of not initializing 309fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Google Test before calling RUN_ALL_TESTS(). 310fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 311fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A user must call testing::InitGoogleTest() to initialize Google 312fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Test. g_init_gtest_count is set to the number of times 313fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// InitGoogleTest() has been called. We don't protect this variable 314fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// under a mutex as it is only accessed in the main thread. 31536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeGTEST_API_ int g_init_gtest_count = 0; 316fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool GTestIsInitialized() { return g_init_gtest_count != 0; } 317fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 318fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Iterates over a vector of TestCases, keeping a running sum of the 319fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// results of calling a given int-returning method on each. 320fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the sum. 321fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic int SumOverTestCaseList(const std::vector<TestCase*>& case_list, 322fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int (TestCase::*method)() const) { 323fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int sum = 0; 324fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < case_list.size(); i++) { 325fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt sum += (case_list[i]->*method)(); 326fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 327fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return sum; 328fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 329fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 330fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test case passed. 331fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool TestCasePassed(const TestCase* test_case) { 332fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_case->should_run() && test_case->Passed(); 333fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 334fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 335fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test case failed. 336fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool TestCaseFailed(const TestCase* test_case) { 337fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_case->should_run() && test_case->Failed(); 338fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 339fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 340fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff test_case contains at least one test that should 341fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// run. 342fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool ShouldRunTestCase(const TestCase* test_case) { 343fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_case->should_run(); 344fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 345fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 346fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// AssertHelper constructor. 347fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertHelper::AssertHelper(TestPartResult::Type type, 348fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* file, 349fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int line, 350fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* message) 351fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : data_(new AssertHelperData(type, file, line, message)) { 352fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 353fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 354fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertHelper::~AssertHelper() { 355fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete data_; 356fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 357fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 358fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Message assignment, for assertion streaming support. 359fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid AssertHelper::operator=(const Message& message) const { 360fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTest::GetInstance()-> 361fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt AddTestPartResult(data_->type, data_->file, data_->line, 362fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt AppendUserMessage(data_->message, message), 363fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTest::GetInstance()->impl() 364fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ->CurrentOsStackTraceExceptTop(1) 365fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Skips the stack frame for this function itself. 366fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ); // NOLINT 367fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 368fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 369fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Mutex for linked pointers. 37036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeGTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex); 371fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 372fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Application pathname gotten in InitGoogleTest. 37336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string g_executable_path; 374fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 375fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the current application's name, removing directory path if that 376fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// is present. 377fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtFilePath GetCurrentExecutableName() { 378fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FilePath result; 379fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 380fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS 381fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result.Set(FilePath(g_executable_path).RemoveExtension("exe")); 382fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 383fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result.Set(FilePath(g_executable_path)); 384fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS 385fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 386fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return result.RemoveDirectoryName(); 387fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 388fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 389fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Functions for processing the gtest_output flag. 390fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 391fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the output format, or "" for normal printed output. 39236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string UnitTestOptions::GetOutputFormat() { 393fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); 39436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (gtest_output_flag == NULL) return std::string(""); 395fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 396fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const colon = strchr(gtest_output_flag, ':'); 397fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (colon == NULL) ? 39836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string(gtest_output_flag) : 39936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string(gtest_output_flag, colon - gtest_output_flag); 400fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 401fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 402fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the name of the requested output file, or the default if none 403fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// was explicitly specified. 40436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string UnitTestOptions::GetAbsolutePathToOutputFile() { 405fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); 406fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (gtest_output_flag == NULL) 40736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ""; 408fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 409fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const colon = strchr(gtest_output_flag, ':'); 410fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (colon == NULL) 41136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return internal::FilePath::ConcatPaths( 41236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee internal::FilePath( 41336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee UnitTest::GetInstance()->original_working_dir()), 41436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee internal::FilePath(kDefaultOutputFile)).string(); 415fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 416fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::FilePath output_name(colon + 1); 417fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!output_name.IsAbsolutePath()) 418fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TODO(wan@google.com): on Windows \some\path is not an absolute 419fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // path (as its meaning depends on the current drive), yet the 420fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // following logic for turning it into an absolute path is wrong. 421fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Fix it. 422fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output_name = internal::FilePath::ConcatPaths( 423fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::FilePath(UnitTest::GetInstance()->original_working_dir()), 424fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::FilePath(colon + 1)); 425fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 426fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!output_name.IsDirectory()) 42736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return output_name.string(); 428fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 429fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::FilePath result(internal::FilePath::GenerateUniqueFileName( 430fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output_name, internal::GetCurrentExecutableName(), 431fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetOutputFormat().c_str())); 43236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return result.string(); 433fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 434fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 435fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the wildcard pattern matches the string. The 436fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// first ':' or '\0' character in pattern marks the end of it. 437fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 438fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This recursive algorithm isn't very efficient, but is clear and 439fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// works well enough for matching test names, which are short. 440fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool UnitTestOptions::PatternMatchesString(const char *pattern, 441fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char *str) { 442fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt switch (*pattern) { 443fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '\0': 444fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case ':': // Either ':' or '\0' marks the end of the pattern. 445fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *str == '\0'; 446fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '?': // Matches any single character. 447fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *str != '\0' && PatternMatchesString(pattern + 1, str + 1); 448fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '*': // Matches any string (possibly empty) of characters. 449fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || 450fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PatternMatchesString(pattern + 1, str); 451fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default: // Non-special character. Matches itself. 452fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *pattern == *str && 453fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PatternMatchesString(pattern + 1, str + 1); 454fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 455fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 456fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 45736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leebool UnitTestOptions::MatchesFilter( 45836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& name, const char* filter) { 459fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char *cur_pattern = filter; 460fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (;;) { 461fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (PatternMatchesString(cur_pattern, name.c_str())) { 462fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 463fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 464fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 465fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Finds the next pattern in the filter. 466fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt cur_pattern = strchr(cur_pattern, ':'); 467fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 468fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns if no more pattern can be found. 469fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (cur_pattern == NULL) { 470fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 471fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 472fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 473fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Skips the pattern separater (the ':' character). 474fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt cur_pattern++; 475fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 476fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 477fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 478fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the user-specified filter matches the test case 479fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// name and the test name. 48036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leebool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name, 48136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string &test_name) { 48236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& full_name = test_case_name + "." + test_name.c_str(); 483fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 484fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Split --gtest_filter at '-', if there is one, to separate into 485fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // positive filter and negative filter portions 486fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const p = GTEST_FLAG(filter).c_str(); 487fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const dash = strchr(p, '-'); 48836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string positive; 48936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string negative; 490fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (dash == NULL) { 491fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter 49236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee negative = ""; 493fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 49436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee positive = std::string(p, dash); // Everything up to the dash 49536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee negative = std::string(dash + 1); // Everything after the dash 496fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (positive.empty()) { 497fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Treat '-test1' as the same as '*-test1' 498fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt positive = kUniversalFilter; 499fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 500fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 501fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 502fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // A filter is a colon-separated list of patterns. It matches a 503fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // test if any pattern in it matches the test. 504fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (MatchesFilter(full_name, positive.c_str()) && 505fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt !MatchesFilter(full_name, negative.c_str())); 506fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 507fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 508fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_SEH 509fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the 510fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. 511fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This function is useful as an __except condition. 512fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { 513fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Google Test should handle a SEH exception if: 514fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 1. the user wants it to, AND 515fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 2. this is not a breakpoint exception, AND 516fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 3. this is not a C++ exception (VC++ implements them via SEH, 517fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // apparently). 518fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 519fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // SEH exception code for C++ exceptions. 520fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // (see http://support.microsoft.com/kb/185294 for more information). 521fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const DWORD kCxxExceptionCode = 0xe06d7363; 522fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 523fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool should_handle = true; 524fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 525fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!GTEST_FLAG(catch_exceptions)) 526fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt should_handle = false; 527fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt else if (exception_code == EXCEPTION_BREAKPOINT) 528fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt should_handle = false; 529fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt else if (exception_code == kCxxExceptionCode) 530fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt should_handle = false; 531fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 532fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; 533fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 534fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_SEH 535fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 536fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 537fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 538fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The c'tor sets this object as the test part result reporter used by 539fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Google Test. The 'result' parameter specifies where to report the 540fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// results. Intercepts only failures from the current thread. 541fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( 542fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResultArray* result) 543fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), 544fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result_(result) { 545fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Init(); 546fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 547fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 548fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The c'tor sets this object as the test part result reporter used by 549fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Google Test. The 'result' parameter specifies where to report the 550fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// results. 551fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( 552fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt InterceptMode intercept_mode, TestPartResultArray* result) 553fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : intercept_mode_(intercept_mode), 554fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result_(result) { 555fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Init(); 556fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 557fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 558fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ScopedFakeTestPartResultReporter::Init() { 559fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 560fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (intercept_mode_ == INTERCEPT_ALL_THREADS) { 561fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt old_reporter_ = impl->GetGlobalTestPartResultReporter(); 562fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->SetGlobalTestPartResultReporter(this); 563fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 564fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); 565fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->SetTestPartResultReporterForCurrentThread(this); 566fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 567fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 568fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 569fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The d'tor restores the test part result reporter used by Google Test 570fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// before. 571fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { 572fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 573fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (intercept_mode_ == INTERCEPT_ALL_THREADS) { 574fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->SetGlobalTestPartResultReporter(old_reporter_); 575fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 576fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->SetTestPartResultReporterForCurrentThread(old_reporter_); 577fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 578fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 579fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 580fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Increments the test part result count and remembers the result. 581fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This method is from the TestPartResultReporterInterface interface. 582fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ScopedFakeTestPartResultReporter::ReportTestPartResult( 583fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& result) { 584fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result_->Append(result); 585fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 586fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 587fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 588fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 589fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the type ID of ::testing::Test. We should always call this 590fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// instead of GetTypeId< ::testing::Test>() to get the type ID of 591fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// testing::Test. This is to work around a suspected linker bug when 592fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// using Google Test as a framework on Mac OS X. The bug causes 593fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// GetTypeId< ::testing::Test>() to return different values depending 594fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// on whether the call is from the Google Test framework itself or 595fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// from user test code. GetTestTypeId() is guaranteed to always 596fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// return the same value, as it always calls GetTypeId<>() from the 597fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// gtest.cc, which is within the Google Test framework. 598fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTypeId GetTestTypeId() { 599fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return GetTypeId<Test>(); 600fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 601fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 602fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The value of GetTestTypeId() as seen from within the Google Test 603fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// library. This is solely for testing GetTestTypeId(). 604fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtextern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); 605fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 606fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This predicate-formatter checks that 'results' contains a test part 607fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// failure of the given type and that the failure message contains the 608fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// given substring. 609fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult HasOneFailure(const char* /* results_expr */, 610fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* /* type_expr */, 611fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* /* substr_expr */, 612fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResultArray& results, 613fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResult::Type type, 614fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const string& substr) { 61536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string expected(type == TestPartResult::kFatalFailure ? 616fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "1 fatal failure" : 617fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "1 non-fatal failure"); 618fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message msg; 619fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (results.size() != 1) { 620fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "Expected: " << expected << "\n" 621fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " Actual: " << results.size() << " failures"; 622fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < results.size(); i++) { 623fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\n" << results.GetTestPartResult(i); 624fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 625fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << msg; 626fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 627fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 628fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& r = results.GetTestPartResult(0); 629fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (r.type() != type) { 630fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << "Expected: " << expected << "\n" 631fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " Actual:\n" 632fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << r; 633fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 634fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 635fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (strstr(r.message(), substr.c_str()) == NULL) { 636fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << "Expected: " << expected << " containing \"" 637fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << substr << "\"\n" 638fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " Actual:\n" 639fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << r; 640fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 641fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 642fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 643fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 644fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 645fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The constructor of SingleFailureChecker remembers where to look up 646fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// test part results, what type of failure we expect, and what 647fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// substring the failure message should contain. 648fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtSingleFailureChecker:: SingleFailureChecker( 649fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResultArray* results, 650fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResult::Type type, 651fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const string& substr) 652fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : results_(results), 653fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt type_(type), 654fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt substr_(substr) {} 655fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 656fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The destructor of SingleFailureChecker verifies that the given 657fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TestPartResultArray contains exactly one failure that has the given 658fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// type and contains the given substring. If that's not the case, a 659fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// non-fatal failure will be generated. 660fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtSingleFailureChecker::~SingleFailureChecker() { 661fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); 662fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 663fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 664fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtDefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( 665fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTestImpl* unit_test) : unit_test_(unit_test) {} 666fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 667fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid DefaultGlobalTestPartResultReporter::ReportTestPartResult( 668fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& result) { 669fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unit_test_->current_test_result()->AddTestPartResult(result); 670fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unit_test_->listeners()->repeater()->OnTestPartResult(result); 671fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 672fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 673fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtDefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( 674fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTestImpl* unit_test) : unit_test_(unit_test) {} 675fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 676fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid DefaultPerThreadTestPartResultReporter::ReportTestPartResult( 677fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& result) { 678fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); 679fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 680fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 681fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the global test part result reporter. 682fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestPartResultReporterInterface* 683fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUnitTestImpl::GetGlobalTestPartResultReporter() { 684fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&global_test_part_result_reporter_mutex_); 685fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return global_test_part_result_repoter_; 686fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 687fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 688fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Sets the global test part result reporter. 689fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::SetGlobalTestPartResultReporter( 690fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResultReporterInterface* reporter) { 691fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&global_test_part_result_reporter_mutex_); 692fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt global_test_part_result_repoter_ = reporter; 693fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 694fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 695fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the test part result reporter for the current thread. 696fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestPartResultReporterInterface* 697fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUnitTestImpl::GetTestPartResultReporterForCurrentThread() { 698fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return per_thread_test_part_result_reporter_.get(); 699fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 700fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 701fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Sets the test part result reporter for the current thread. 702fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::SetTestPartResultReporterForCurrentThread( 703fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResultReporterInterface* reporter) { 704fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt per_thread_test_part_result_reporter_.set(reporter); 705fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 706fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 707fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of successful test cases. 708fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::successful_test_case_count() const { 709fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_cases_, TestCasePassed); 710fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 711fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 712fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of failed test cases. 713fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::failed_test_case_count() const { 714fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_cases_, TestCaseFailed); 715fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 716fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 717fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all test cases. 718fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::total_test_case_count() const { 719fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<int>(test_cases_.size()); 720fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 721fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 722fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all test cases that contain at least one test 723fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// that should run. 724fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::test_case_to_run_count() const { 725fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_cases_, ShouldRunTestCase); 726fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 727fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 728fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of successful tests. 729fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::successful_test_count() const { 730fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); 731fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 732fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 733fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of failed tests. 734fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::failed_test_count() const { 735fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); 736fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 737fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 73836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of disabled tests that will be reported in the XML report. 73936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeint UnitTestImpl::reportable_disabled_test_count() const { 74036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return SumOverTestCaseList(test_cases_, 74136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee &TestCase::reportable_disabled_test_count); 74236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 74336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 744fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of disabled tests. 745fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::disabled_test_count() const { 746fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); 747fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 748fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 74936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of tests to be printed in the XML report. 75036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeint UnitTestImpl::reportable_test_count() const { 75136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count); 75236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 75336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 754fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all tests. 755fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::total_test_count() const { 756fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); 757fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 758fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 759fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of tests that should run. 760fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::test_to_run_count() const { 761fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); 762fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 763fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 76436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Returns the current OS stack trace as an std::string. 765fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 766fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The maximum number of stack frames to be included is specified by 767fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the gtest_stack_trace_depth flag. The skip_count parameter 768fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// specifies the number of top frames to be skipped, which doesn't 769fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// count against the number of frames to be included. 770fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 771fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// For example, if Foo() calls Bar(), which in turn calls 772fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// CurrentOsStackTraceExceptTop(1), Foo() will be included in the 773fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// trace but Bar() and CurrentOsStackTraceExceptTop() won't. 77436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { 775fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (void)skip_count; 77636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ""; 777fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 778fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 779fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the current time in milliseconds. 780fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTimeInMillis GetTimeInMillis() { 781fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) 782fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Difference between 1970-01-01 and 1601-01-01 in milliseconds. 783fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // http://analogous.blogspot.com/2005/04/epoch.html 784fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TimeInMillis kJavaEpochToWinFileTimeDelta = 785fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static_cast<TimeInMillis>(116444736UL) * 100000UL; 786fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const DWORD kTenthMicrosInMilliSecond = 10000; 787fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 788fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SYSTEMTIME now_systime; 789fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FILETIME now_filetime; 790fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ULARGE_INTEGER now_int64; 791fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TODO(kenton@google.com): Shouldn't this just use 792fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // GetSystemTimeAsFileTime()? 793fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetSystemTime(&now_systime); 794fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (SystemTimeToFileTime(&now_systime, &now_filetime)) { 795fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt now_int64.LowPart = now_filetime.dwLowDateTime; 796fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt now_int64.HighPart = now_filetime.dwHighDateTime; 797fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - 798fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt kJavaEpochToWinFileTimeDelta; 799fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return now_int64.QuadPart; 800fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 801fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return 0; 802fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ 803fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt __timeb64 now; 804fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 805fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# ifdef _MSC_VER 806fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 807fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 808fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // (deprecated function) there. 809fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TODO(kenton@google.com): Use GetTickCount()? Or use 810fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // SystemTimeToFileTime() 811fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# pragma warning(push) // Saves the current warning state. 812fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# pragma warning(disable:4996) // Temporarily disables warning 4996. 813fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt _ftime64(&now); 814fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# pragma warning(pop) // Restores the warning state. 815fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# else 816fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 817fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt _ftime64(&now); 818fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 819fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# endif // _MSC_VER 820fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 821fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; 822fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_HAS_GETTIMEOFDAY_ 823fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt struct timeval now; 824fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt gettimeofday(&now, NULL); 825fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000; 826fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 827fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# error "Don't know how to get the current time on your system." 828fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 829fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 830fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 831fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Utilities 832fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 83336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// class String. 834fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 835fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS_MOBILE 836fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates a UTF-16 wide string from the given ANSI string, allocating 837fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// memory using new. The caller is responsible for deleting the return 838fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value using delete[]. Returns the wide string, or NULL if the 839fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// input is NULL. 840fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtLPCWSTR String::AnsiToUtf16(const char* ansi) { 841fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!ansi) return NULL; 842fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int length = strlen(ansi); 843fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int unicode_length = 844fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt MultiByteToWideChar(CP_ACP, 0, ansi, length, 845fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt NULL, 0); 846fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt WCHAR* unicode = new WCHAR[unicode_length + 1]; 847fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt MultiByteToWideChar(CP_ACP, 0, ansi, length, 848fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unicode, unicode_length); 849fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unicode[unicode_length] = 0; 850fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return unicode; 851fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 852fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 853fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates an ANSI string from the given wide string, allocating 854fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// memory using new. The caller is responsible for deleting the return 855fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value using delete[]. Returns the ANSI string, or NULL if the 856fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// input is NULL. 857fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst char* String::Utf16ToAnsi(LPCWSTR utf16_str) { 858fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!utf16_str) return NULL; 859fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int ansi_length = 860fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, 861fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt NULL, 0, NULL, NULL); 862fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt char* ansi = new char[ansi_length + 1]; 863fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, 864fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ansi, ansi_length, NULL, NULL); 865fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ansi[ansi_length] = 0; 866fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return ansi; 867fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 868fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 869fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS_MOBILE 870fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 871fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Compares two C strings. Returns true iff they have the same content. 872fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 873fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Unlike strcmp(), this function can handle NULL argument(s). A NULL 874fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// C string is considered different to any non-NULL C string, 875fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// including the empty string. 876fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool String::CStringEquals(const char * lhs, const char * rhs) { 877fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if ( lhs == NULL ) return rhs == NULL; 878fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 879fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if ( rhs == NULL ) return false; 880fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 881fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return strcmp(lhs, rhs) == 0; 882fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 883fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 884fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 885fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 886fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Converts an array of wide chars to a narrow string using the UTF-8 887fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// encoding, and streams the result to the given Message object. 888fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, 889fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message* msg) { 890fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i != length; ) { // NOLINT 891fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (wstr[i] != L'\0') { 892fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i)); 893fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt while (i != length && wstr[i] != L'\0') 894fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt i++; 895fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 896fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *msg << '\0'; 897fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt i++; 898fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 899fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 900fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 901fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 902fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 903fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 904fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 905fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 90636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Constructs an empty Message. 90736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// We allocate the stringstream separately because otherwise each use of 90836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's 90936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// stack frame leading to huge stack frames in some cases; gcc does not reuse 91036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// the stack space. 91136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeMessage::Message() : ss_(new ::std::stringstream) { 91236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // By default, we want there to be enough precision when printing 91336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // a double to a Message. 91436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2); 91536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 91636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 91736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// These two overloads allow streaming a wide C string to a Message 91836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// using the UTF-8 encoding. 91936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeMessage& Message::operator <<(const wchar_t* wide_c_str) { 92036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return *this << internal::String::ShowWideCString(wide_c_str); 92136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 92236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeMessage& Message::operator <<(wchar_t* wide_c_str) { 92336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return *this << internal::String::ShowWideCString(wide_c_str); 92436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 92536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 926fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_STD_WSTRING 927fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Converts the given wide string to a narrow string using the UTF-8 928fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// encoding, and streams the result to this Message object. 929fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtMessage& Message::operator <<(const ::std::wstring& wstr) { 930fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); 931fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *this; 932fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 933fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_STD_WSTRING 934fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 935fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_GLOBAL_WSTRING 936fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Converts the given wide string to a narrow string using the UTF-8 937fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// encoding, and streams the result to this Message object. 938fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtMessage& Message::operator <<(const ::wstring& wstr) { 939fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); 940fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *this; 941fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 942fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_GLOBAL_WSTRING 943fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 94436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the text streamed to this object so far as an std::string. 94536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Each '\0' character in the buffer is replaced with "\\0". 94636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string Message::GetString() const { 94736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return internal::StringStreamToString(ss_.get()); 94836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 94936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 950fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// AssertionResult constructors. 951fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Used in EXPECT_TRUE/FALSE(assertion_result). 952fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult::AssertionResult(const AssertionResult& other) 953fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : success_(other.success_), 954fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt message_(other.message_.get() != NULL ? 955fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt new ::std::string(*other.message_) : 956fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static_cast< ::std::string*>(NULL)) { 957fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 958fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 959fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. 960fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult AssertionResult::operator!() const { 961fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt AssertionResult negation(!success_); 962fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (message_.get() != NULL) 963fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt negation << *message_; 964fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return negation; 965fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 966fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 967fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Makes a successful assertion result. 968fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult AssertionSuccess() { 969fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionResult(true); 970fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 971fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 972fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Makes a failed assertion result. 973fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult AssertionFailure() { 974fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionResult(false); 975fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 976fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 977fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Makes a failed assertion result with the given failure message. 978fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Deprecated; use AssertionFailure() << message. 979fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult AssertionFailure(const Message& message) { 980fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << message; 981fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 982fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 983fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 984fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 985fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Constructs and returns the message for an equality assertion 986fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. 987fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 988fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The first four parameters are the expressions used in the assertion 989fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// and their values, as strings. For example, for ASSERT_EQ(foo, bar) 990fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// where foo is 5 and bar is 6, we have: 991fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 992fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// expected_expression: "foo" 993fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// actual_expression: "bar" 994fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// expected_value: "5" 995fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// actual_value: "6" 996fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 997fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The ignoring_case parameter is true iff the assertion is a 998fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will 999fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// be inserted into the message. 1000fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult EqFailure(const char* expected_expression, 1001fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual_expression, 100236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& expected_value, 100336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& actual_value, 1004fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool ignoring_case) { 1005fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message msg; 1006fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "Value of: " << actual_expression; 1007fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (actual_value != actual_expression) { 1008fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\n Actual: " << actual_value; 1009fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1010fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1011fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\nExpected: " << expected_expression; 1012fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (ignoring_case) { 1013fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << " (ignoring case)"; 1014fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1015fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (expected_value != expected_expression) { 1016fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\nWhich is: " << expected_value; 1017fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1018fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1019fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << msg; 1020fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1021fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1022fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. 102336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string GetBoolAssertionFailureMessage( 102436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const AssertionResult& assertion_result, 102536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* expression_text, 102636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* actual_predicate_value, 102736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* expected_predicate_value) { 1028fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual_message = assertion_result.message(); 1029fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message msg; 1030fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "Value of: " << expression_text 1031fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "\n Actual: " << actual_predicate_value; 1032fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (actual_message[0] != '\0') 1033fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << " (" << actual_message << ")"; 1034fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\nExpected: " << expected_predicate_value; 1035fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return msg.GetString(); 1036fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1037fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1038fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helper function for implementing ASSERT_NEAR. 1039fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult DoubleNearPredFormat(const char* expr1, 1040fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* expr2, 1041fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* abs_error_expr, 1042fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt double val1, 1043fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt double val2, 1044fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt double abs_error) { 1045fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const double diff = fabs(val1 - val2); 1046fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (diff <= abs_error) return AssertionSuccess(); 1047fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1048fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TODO(wan): do not print the value of an expression if it's 1049fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // already a literal. 1050fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() 1051fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "The difference between " << expr1 << " and " << expr2 1052fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" 1053fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << expr1 << " evaluates to " << val1 << ",\n" 1054fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << expr2 << " evaluates to " << val2 << ", and\n" 1055fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << abs_error_expr << " evaluates to " << abs_error << "."; 1056fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1057fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1058fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1059fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helper template for implementing FloatLE() and DoubleLE(). 1060fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <typename RawType> 1061fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult FloatingPointLE(const char* expr1, 1062fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* expr2, 1063fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt RawType val1, 1064fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt RawType val2) { 1065fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns success if val1 is less than val2, 1066fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (val1 < val2) { 1067fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1068fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1069fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1070fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // or if val1 is almost equal to val2. 1071fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const FloatingPoint<RawType> lhs(val1), rhs(val2); 1072fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (lhs.AlmostEquals(rhs)) { 1073fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1074fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1075fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1076fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Note that the above two checks will both fail if either val1 or 1077fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // val2 is NaN, as the IEEE floating-point standard requires that 1078fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // any predicate involving a NaN must return false. 1079fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1080fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ::std::stringstream val1_ss; 1081fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1082fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << val1; 1083fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1084fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ::std::stringstream val2_ss; 1085fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1086fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << val2; 1087fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1088fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() 1089fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" 1090fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " Actual: " << StringStreamToString(&val1_ss) << " vs " 1091fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << StringStreamToString(&val2_ss); 1092fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1093fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1094fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 1095fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1096fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Asserts that val1 is less than, or almost equal to, val2. Fails 1097fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// otherwise. In particular, it fails if either val1 or val2 is NaN. 1098fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult FloatLE(const char* expr1, const char* expr2, 1099fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt float val1, float val2) { 1100fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return internal::FloatingPointLE<float>(expr1, expr2, val1, val2); 1101fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1102fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1103fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Asserts that val1 is less than, or almost equal to, val2. Fails 1104fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// otherwise. In particular, it fails if either val1 or val2 is NaN. 1105fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult DoubleLE(const char* expr1, const char* expr2, 1106fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt double val1, double val2) { 1107fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return internal::FloatingPointLE<double>(expr1, expr2, val1, val2); 1108fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1109fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1110fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 1111fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1112fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The helper function for {ASSERT|EXPECT}_EQ with int or enum 1113fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// arguments. 1114fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperEQ(const char* expected_expression, 1115fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual_expression, 1116fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt BiggestInt expected, 1117fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt BiggestInt actual) { 1118fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (expected == actual) { 1119fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1120fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1121fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1122fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return EqFailure(expected_expression, 1123fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt actual_expression, 1124fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatForComparisonFailureMessage(expected, actual), 1125fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatForComparisonFailureMessage(actual, expected), 1126fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt false); 1127fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1128fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1129fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A macro for implementing the helper functions needed to implement 1130fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here 1131fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// just to avoid copy-and-paste of similar code. 1132fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ 1133fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ 1134fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt BiggestInt val1, BiggestInt val2) {\ 1135fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (val1 op val2) {\ 1136fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess();\ 1137fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else {\ 1138fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() \ 1139fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Expected: (" << expr1 << ") " #op " (" << expr2\ 1140fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ 1141fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " vs " << FormatForComparisonFailureMessage(val2, val1);\ 1142fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt }\ 1143fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1144fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1145fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Implements the helper function for {ASSERT|EXPECT}_NE with int or 1146fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// enum arguments. 1147fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_IMPL_CMP_HELPER_(NE, !=) 1148fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Implements the helper function for {ASSERT|EXPECT}_LE with int or 1149fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// enum arguments. 1150fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_IMPL_CMP_HELPER_(LE, <=) 1151fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Implements the helper function for {ASSERT|EXPECT}_LT with int or 1152fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// enum arguments. 1153fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_IMPL_CMP_HELPER_(LT, < ) 1154fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Implements the helper function for {ASSERT|EXPECT}_GE with int or 1155fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// enum arguments. 1156fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_IMPL_CMP_HELPER_(GE, >=) 1157fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Implements the helper function for {ASSERT|EXPECT}_GT with int or 1158fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// enum arguments. 1159fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_IMPL_CMP_HELPER_(GT, > ) 1160fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1161fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#undef GTEST_IMPL_CMP_HELPER_ 1162fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1163fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The helper function for {ASSERT|EXPECT}_STREQ. 1164fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperSTREQ(const char* expected_expression, 1165fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual_expression, 1166fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* expected, 1167fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual) { 1168fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (String::CStringEquals(expected, actual)) { 1169fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1170fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1171fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1172fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return EqFailure(expected_expression, 1173fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt actual_expression, 117436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintToString(expected), 117536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintToString(actual), 1176fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt false); 1177fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1178fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1179fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The helper function for {ASSERT|EXPECT}_STRCASEEQ. 1180fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, 1181fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual_expression, 1182fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* expected, 1183fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual) { 1184fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (String::CaseInsensitiveCStringEquals(expected, actual)) { 1185fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1186fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1187fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1188fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return EqFailure(expected_expression, 1189fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt actual_expression, 119036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintToString(expected), 119136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintToString(actual), 1192fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt true); 1193fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1194fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1195fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The helper function for {ASSERT|EXPECT}_STRNE. 1196fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperSTRNE(const char* s1_expression, 1197fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s2_expression, 1198fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s1, 1199fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s2) { 1200fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!String::CStringEquals(s1, s2)) { 1201fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1202fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 1203fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << "Expected: (" << s1_expression << ") != (" 1204fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << s2_expression << "), actual: \"" 1205fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << s1 << "\" vs \"" << s2 << "\""; 1206fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1207fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1208fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1209fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The helper function for {ASSERT|EXPECT}_STRCASENE. 1210fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperSTRCASENE(const char* s1_expression, 1211fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s2_expression, 1212fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s1, 1213fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s2) { 1214fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!String::CaseInsensitiveCStringEquals(s1, s2)) { 1215fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1216fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 1217fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() 1218fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Expected: (" << s1_expression << ") != (" 1219fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << s2_expression << ") (ignoring case), actual: \"" 1220fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << s1 << "\" vs \"" << s2 << "\""; 1221fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1222fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1223fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1224fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 1225fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1226fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace { 1227fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1228fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helper functions for implementing IsSubString() and IsNotSubstring(). 1229fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1230fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This group of overloaded functions return true iff needle is a 1231fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// substring of haystack. NULL is considered a substring of itself 1232fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// only. 1233fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1234fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool IsSubstringPred(const char* needle, const char* haystack) { 1235fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (needle == NULL || haystack == NULL) 1236fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return needle == haystack; 1237fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1238fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return strstr(haystack, needle) != NULL; 1239fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1240fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1241fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { 1242fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (needle == NULL || haystack == NULL) 1243fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return needle == haystack; 1244fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1245fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return wcsstr(haystack, needle) != NULL; 1246fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1247fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1248fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// StringType here can be either ::std::string or ::std::wstring. 1249fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <typename StringType> 1250fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool IsSubstringPred(const StringType& needle, 1251fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const StringType& haystack) { 1252fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return haystack.find(needle) != StringType::npos; 1253fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1254fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1255fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This function implements either IsSubstring() or IsNotSubstring(), 1256fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// depending on the value of the expected_to_be_substring parameter. 1257fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// StringType here can be const char*, const wchar_t*, ::std::string, 1258fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// or ::std::wstring. 1259fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <typename StringType> 1260fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsSubstringImpl( 1261fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool expected_to_be_substring, 1262fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1263fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const StringType& needle, const StringType& haystack) { 1264fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (IsSubstringPred(needle, haystack) == expected_to_be_substring) 1265fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1266fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1267fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool is_wide_string = sizeof(needle[0]) > 1; 1268fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; 1269fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() 1270fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Value of: " << needle_expr << "\n" 1271fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " Actual: " << begin_string_quote << needle << "\"\n" 1272fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Expected: " << (expected_to_be_substring ? "" : "not ") 1273fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "a substring of " << haystack_expr << "\n" 1274fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Which is: " << begin_string_quote << haystack << "\""; 1275fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1276fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1277fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace 1278fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1279fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// IsSubstring() and IsNotSubstring() check whether needle is a 1280fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// substring of haystack (NULL is considered a substring of itself 1281fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// only), and return an appropriate error message when they fail. 1282fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1283fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsSubstring( 1284fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1285fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle, const char* haystack) { 1286fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1287fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1288fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1289fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsSubstring( 1290fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1291fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* needle, const wchar_t* haystack) { 1292fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1293fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1294fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1295fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsNotSubstring( 1296fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1297fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle, const char* haystack) { 1298fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1299fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1300fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1301fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsNotSubstring( 1302fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1303fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* needle, const wchar_t* haystack) { 1304fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1305fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1306fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1307fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsSubstring( 1308fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1309fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const ::std::string& needle, const ::std::string& haystack) { 1310fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1311fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1312fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1313fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsNotSubstring( 1314fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1315fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const ::std::string& needle, const ::std::string& haystack) { 1316fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1317fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1318fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1319fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_STD_WSTRING 1320fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsSubstring( 1321fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1322fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const ::std::wstring& needle, const ::std::wstring& haystack) { 1323fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 1324fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1325fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1326fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsNotSubstring( 1327fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* needle_expr, const char* haystack_expr, 1328fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const ::std::wstring& needle, const ::std::wstring& haystack) { 1329fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 1330fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1331fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_STD_WSTRING 1332fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1333fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 1334fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1335fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS 1336fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1337fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace { 1338fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1339fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helper function for IsHRESULT{SuccessFailure} predicates 1340fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult HRESULTFailureHelper(const char* expr, 1341fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* expected, 1342fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt long hr) { // NOLINT 1343fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# if GTEST_OS_WINDOWS_MOBILE 1344fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1345fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Windows CE doesn't support FormatMessage. 1346fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char error_text[] = ""; 1347fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1348fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# else 1349fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1350fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Looks up the human-readable system message for the HRESULT code 1351fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // and since we're not passing any params to FormatMessage, we don't 1352fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // want inserts expanded. 1353fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | 1354fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FORMAT_MESSAGE_IGNORE_INSERTS; 135536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const DWORD kBufSize = 4096; 1356fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the system's human readable message string for this HRESULT. 1357fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt char error_text[kBufSize] = { '\0' }; 1358fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt DWORD message_length = ::FormatMessageA(kFlags, 1359fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 0, // no source, we're asking system 1360fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt hr, // the error 1361fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 0, // no line width restrictions 1362fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt error_text, // output buffer 1363fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt kBufSize, // buf size 1364fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt NULL); // no arguments for inserts 136536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // Trims tailing white space (FormatMessage leaves a trailing CR-LF) 1366fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (; message_length && IsSpace(error_text[message_length - 1]); 1367fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt --message_length) { 1368fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt error_text[message_length - 1] = '\0'; 1369fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1370fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1371fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# endif // GTEST_OS_WINDOWS_MOBILE 1372fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 137336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string error_hex("0x" + String::FormatHexInt(hr)); 1374fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return ::testing::AssertionFailure() 1375fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Expected: " << expr << " " << expected << ".\n" 137636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << " Actual: " << error_hex << " " << error_text << "\n"; 1377fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1378fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1379fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace 1380fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1381fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT 1382fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (SUCCEEDED(hr)) { 1383fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1384fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1385fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return HRESULTFailureHelper(expr, "succeeds", hr); 1386fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1387fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1388fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT 1389fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (FAILED(hr)) { 1390fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1391fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1392fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return HRESULTFailureHelper(expr, "fails", hr); 1393fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1394fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1395fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS 1396fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1397fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Utility functions for encoding Unicode text (wide strings) in 1398fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// UTF-8. 1399fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1400fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 1401fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// like this: 1402fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 1403fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Code-point length Encoding 1404fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 0 - 7 bits 0xxxxxxx 1405fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 8 - 11 bits 110xxxxx 10xxxxxx 1406fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx 1407fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 1408fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1409fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The maximum code-point a one-byte UTF-8 sequence can represent. 1410fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1; 1411fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1412fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The maximum code-point a two-byte UTF-8 sequence can represent. 1413fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1; 1414fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1415fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The maximum code-point a three-byte UTF-8 sequence can represent. 1416fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1; 1417fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1418fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The maximum code-point a four-byte UTF-8 sequence can represent. 1419fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1; 1420fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1421fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Chops off the n lowest bits from a bit pattern. Returns the n 1422fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// lowest bits. As a side effect, the original bit pattern will be 1423fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// shifted to the right by n bits. 1424fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtinline UInt32 ChopLowBits(UInt32* bits, int n) { 1425fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1); 1426fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *bits >>= n; 1427fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return low_bits; 1428fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1429fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1430fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Converts a Unicode code point to a narrow string in UTF-8 encoding. 1431fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// code_point parameter is of type UInt32 because wchar_t may not be 1432fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// wide enough to contain a code point. 1433fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// If the code_point is not a valid Unicode code point 143436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted 143536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// to "(Invalid Unicode 0xXXXXXXXX)". 143636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string CodePointToUtf8(UInt32 code_point) { 143736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (code_point > kMaxCodePoint4) { 143836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")"; 143936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 144036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 144136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee char str[5]; // Big enough for the largest valid code point. 1442fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (code_point <= kMaxCodePoint1) { 1443fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[1] = '\0'; 1444fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[0] = static_cast<char>(code_point); // 0xxxxxxx 1445fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (code_point <= kMaxCodePoint2) { 1446fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[2] = '\0'; 1447fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1448fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx 1449fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (code_point <= kMaxCodePoint3) { 1450fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[3] = '\0'; 1451fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1452fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1453fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx 145436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else { // code_point <= kMaxCodePoint4 1455fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[4] = '\0'; 1456fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1457fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1458fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 1459fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx 1460fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1461fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return str; 1462fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1463fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 146460a27ad122128145d28be37e9c0b0bc86a8e5181Giuseppe Bilotta// The following two functions only make sense if the system 1465fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// uses UTF-16 for wide string encoding. All supported systems 1466fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. 1467fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1468fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Determines if the arguments constitute UTF-16 surrogate pair 1469fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// and thus should be combined into a single Unicode code point 1470fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// using CreateCodePointFromUtf16SurrogatePair. 1471fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtinline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { 1472fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return sizeof(wchar_t) == 2 && 1473fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; 1474fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1475fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1476fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates a Unicode code point from UTF16 surrogate pair. 1477fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtinline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, 1478fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt wchar_t second) { 1479fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const UInt32 mask = (1 << 10) - 1; 1480fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (sizeof(wchar_t) == 2) ? 1481fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (((first & mask) << 10) | (second & mask)) + 0x10000 : 1482fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This function should not be called when the condition is 1483fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // false, but we provide a sensible default in case it is. 1484fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static_cast<UInt32>(first); 1485fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1486fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1487fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Converts a wide string to a narrow string in UTF-8 encoding. 1488fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The wide string is assumed to have the following encoding: 1489fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) 1490fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// UTF-32 if sizeof(wchar_t) == 4 (on Linux) 1491fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parameter str points to a null-terminated wide string. 1492fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parameter num_chars may additionally limit the number 1493fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// of wchar_t characters processed. -1 is used when the entire string 1494fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// should be processed. 1495fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// If the string contains code points that are not valid Unicode code points 1496fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output 1497fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding 1498fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// and contains invalid UTF-16 surrogate pairs, values in those pairs 1499fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// will be encoded as individual Unicode characters from Basic Normal Plane. 150036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string WideStringToUtf8(const wchar_t* str, int num_chars) { 1501fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (num_chars == -1) 1502fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_chars = static_cast<int>(wcslen(str)); 1503fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1504fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ::std::stringstream stream; 1505fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < num_chars; ++i) { 1506fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UInt32 unicode_code_point; 1507fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1508fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (str[i] == L'\0') { 1509fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt break; 1510fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { 1511fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], 1512fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str[i + 1]); 1513fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt i++; 1514fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 1515fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unicode_code_point = static_cast<UInt32>(str[i]); 1516fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1517fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 151836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee stream << CodePointToUtf8(unicode_code_point); 1519fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1520fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return StringStreamToString(&stream); 1521fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1522fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 152336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Converts a wide C string to an std::string using the UTF-8 encoding. 1524fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// NULL will be converted to "(null)". 152536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string String::ShowWideCString(const wchar_t * wide_c_str) { 152636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (wide_c_str == NULL) return "(null)"; 1527fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 152836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return internal::WideStringToUtf8(wide_c_str, -1); 1529fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1530fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1531fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Compares two wide C strings. Returns true iff they have the same 1532fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// content. 1533fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 1534fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Unlike wcscmp(), this function can handle NULL argument(s). A NULL 1535fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// C string is considered different to any non-NULL C string, 1536fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// including the empty string. 1537fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { 1538fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (lhs == NULL) return rhs == NULL; 1539fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1540fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (rhs == NULL) return false; 1541fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1542fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return wcscmp(lhs, rhs) == 0; 1543fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1544fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1545fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helper function for *_STREQ on wide strings. 1546fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperSTREQ(const char* expected_expression, 1547fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* actual_expression, 1548fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* expected, 1549fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* actual) { 1550fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (String::WideCStringEquals(expected, actual)) { 1551fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1552fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1553fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1554fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return EqFailure(expected_expression, 1555fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt actual_expression, 155636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintToString(expected), 155736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintToString(actual), 1558fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt false); 1559fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1560fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1561fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helper function for *_STRNE on wide strings. 1562fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtAssertionResult CmpHelperSTRNE(const char* s1_expression, 1563fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* s2_expression, 1564fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* s1, 1565fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* s2) { 1566fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!String::WideCStringEquals(s1, s2)) { 1567fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionSuccess(); 1568fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1569fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1570fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return AssertionFailure() << "Expected: (" << s1_expression << ") != (" 1571fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << s2_expression << "), actual: " 157236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << PrintToString(s1) 157336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << " vs " << PrintToString(s2); 1574fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1575fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1576fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Compares two C strings, ignoring case. Returns true iff they have 1577fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the same content. 1578fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 1579fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Unlike strcasecmp(), this function can handle NULL argument(s). A 1580fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// NULL C string is considered different to any non-NULL C string, 1581fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// including the empty string. 1582fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { 1583fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (lhs == NULL) 1584fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return rhs == NULL; 1585fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (rhs == NULL) 1586fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 1587fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return posix::StrCaseCmp(lhs, rhs) == 0; 1588fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1589fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1590fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Compares two wide C strings, ignoring case. Returns true iff they 1591fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // have the same content. 1592fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 1593fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Unlike wcscasecmp(), this function can handle NULL argument(s). 1594fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // A NULL C string is considered different to any non-NULL wide C string, 1595fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // including the empty string. 1596fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // NB: The implementations on different platforms slightly differ. 1597fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // On windows, this method uses _wcsicmp which compares according to LC_CTYPE 1598fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // environment variable. On GNU platform this method uses wcscasecmp 1599fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // which compares according to LC_CTYPE category of the current locale. 1600fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the 1601fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // current locale. 1602fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, 1603fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const wchar_t* rhs) { 1604fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (lhs == NULL) return rhs == NULL; 1605fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1606fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (rhs == NULL) return false; 1607fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1608fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS 1609fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return _wcsicmp(lhs, rhs) == 0; 1610fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID 1611fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return wcscasecmp(lhs, rhs) == 0; 1612fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 1613fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Android, Mac OS X and Cygwin don't define wcscasecmp. 1614fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Other unknown OSes may not define it either. 1615fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt wint_t left, right; 1616fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt do { 1617fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt left = towlower(*lhs++); 1618fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt right = towlower(*rhs++); 1619fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } while (left && left == right); 1620fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return left == right; 1621fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // OS selector 1622fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1623fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 162436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Returns true iff str ends with the given suffix, ignoring case. 162536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Any string is considered to end with an empty suffix. 162636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leebool String::EndsWithCaseInsensitive( 162736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& str, const std::string& suffix) { 162836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const size_t str_len = str.length(); 162936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const size_t suffix_len = suffix.length(); 163036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return (str_len >= suffix_len) && 163136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len, 163236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee suffix.c_str()); 1633fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1634fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 163536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Formats an int value as "%02d". 163636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string String::FormatIntWidth2(int value) { 163736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::stringstream ss; 163836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ss << std::setfill('0') << std::setw(2) << value; 163936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ss.str(); 1640fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1641fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 164236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Formats an int value as "%X". 164336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string String::FormatHexInt(int value) { 164436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::stringstream ss; 164536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ss << std::hex << std::uppercase << value; 164636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ss.str(); 1647fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1648fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 164936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Formats a byte as "%02X". 165036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string String::FormatByte(unsigned char value) { 165136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::stringstream ss; 165236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase 165336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << static_cast<unsigned int>(value); 165436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ss.str(); 1655fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1656fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 165736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Converts the buffer in a stringstream to an std::string, converting NUL 1658fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// bytes to "\\0" along the way. 165936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string StringStreamToString(::std::stringstream* ss) { 1660fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const ::std::string& str = ss->str(); 1661fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const start = str.c_str(); 1662fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const end = start + str.length(); 1663fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 166436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string result; 166536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee result.reserve(2 * (end - start)); 1666fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (const char* ch = start; ch != end; ++ch) { 1667fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (*ch == '\0') { 166836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee result += "\\0"; // Replaces NUL with "\\0"; 1669fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 167036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee result += *ch; 1671fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1672fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1673fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 167436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return result; 1675fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1676fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1677fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Appends the user-supplied message to the Google-Test-generated message. 167836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string AppendUserMessage(const std::string& gtest_msg, 167936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const Message& user_msg) { 1680fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Appends the user message if it's non-empty. 168136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string user_msg_string = user_msg.GetString(); 1682fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (user_msg_string.empty()) { 1683fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return gtest_msg; 1684fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1685fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 168636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return gtest_msg + "\n" + user_msg_string; 1687fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1688fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1689fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 1690fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1691fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class TestResult 1692fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1693fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates an empty TestResult. 1694fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestResult::TestResult() 1695fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : death_test_count_(0), 1696fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt elapsed_time_(0) { 1697fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1698fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1699fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// D'tor. 1700fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestResult::~TestResult() { 1701fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1702fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1703fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the i-th test part result among all the results. i can 1704fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// range from 0 to total_part_count() - 1. If i is not in that range, 1705fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// aborts the program. 1706fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst TestPartResult& TestResult::GetTestPartResult(int i) const { 1707fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (i < 0 || i >= total_part_count()) 1708fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::posix::Abort(); 1709fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_part_results_.at(i); 1710fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1711fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1712fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the i-th test property. i can range from 0 to 1713fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// test_property_count() - 1. If i is not in that range, aborts the 1714fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// program. 1715fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst TestProperty& TestResult::GetTestProperty(int i) const { 1716fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (i < 0 || i >= test_property_count()) 1717fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::posix::Abort(); 1718fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_properties_.at(i); 1719fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1720fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1721fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Clears the test part results. 1722fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestResult::ClearTestPartResults() { 1723fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_part_results_.clear(); 1724fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1725fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1726fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Adds a test part result to the list. 1727fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestResult::AddTestPartResult(const TestPartResult& test_part_result) { 1728fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_part_results_.push_back(test_part_result); 1729fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1730fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1731fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Adds a test property to the list. If a property with the same key as the 1732fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// supplied property is already represented, the value of this test_property 1733fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// replaces the old value for that key. 173436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid TestResult::RecordProperty(const std::string& xml_element, 173536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const TestProperty& test_property) { 173636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (!ValidateTestProperty(xml_element, test_property)) { 1737fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return; 1738fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1739fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&test_properites_mutex_); 1740fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const std::vector<TestProperty>::iterator property_with_matching_key = 1741fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt std::find_if(test_properties_.begin(), test_properties_.end(), 1742fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::TestPropertyKeyIs(test_property.key())); 1743fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (property_with_matching_key == test_properties_.end()) { 1744fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_properties_.push_back(test_property); 1745fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return; 1746fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1747fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt property_with_matching_key->SetValue(test_property.value()); 1748fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1749fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 175036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// The list of reserved attributes used in the <testsuites> element of XML 175136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// output. 175236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic const char* const kReservedTestSuitesAttributes[] = { 175336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "disabled", 175436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "errors", 175536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "failures", 175636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "name", 175736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "random_seed", 175836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "tests", 175936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "time", 176036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "timestamp" 176136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee}; 176236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 176336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// The list of reserved attributes used in the <testsuite> element of XML 176436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// output. 176536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic const char* const kReservedTestSuiteAttributes[] = { 176636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "disabled", 176736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "errors", 176836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "failures", 176936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "name", 177036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "tests", 177136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "time" 177236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee}; 177336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 177436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// The list of reserved attributes used in the <testcase> element of XML output. 177536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic const char* const kReservedTestCaseAttributes[] = { 177636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "classname", 177736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "name", 177836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "status", 177936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "time", 178036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "type_param", 178136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee "value_param" 178236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee}; 178336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 178436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leetemplate <int kSize> 178536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) { 178636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return std::vector<std::string>(array, array + kSize); 178736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 178836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 178936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::vector<std::string> GetReservedAttributesForElement( 179036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& xml_element) { 179136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (xml_element == "testsuites") { 179236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ArrayAsVector(kReservedTestSuitesAttributes); 179336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else if (xml_element == "testsuite") { 179436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ArrayAsVector(kReservedTestSuiteAttributes); 179536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else if (xml_element == "testcase") { 179636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ArrayAsVector(kReservedTestCaseAttributes); 179736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else { 179836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; 179936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 180036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // This code is unreachable but some compilers may not realizes that. 180136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return std::vector<std::string>(); 180236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 180336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 180436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string FormatWordList(const std::vector<std::string>& words) { 180536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee Message word_list; 180636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee for (size_t i = 0; i < words.size(); ++i) { 180736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (i > 0 && words.size() > 2) { 180836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee word_list << ", "; 180936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 181036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (i == words.size() - 1) { 181136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee word_list << "and "; 181236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 181336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee word_list << "'" << words[i] << "'"; 181436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 181536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return word_list.GetString(); 181636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 181736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 181836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leebool ValidateTestPropertyName(const std::string& property_name, 181936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::vector<std::string>& reserved_names) { 182036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (std::find(reserved_names.begin(), reserved_names.end(), property_name) != 182136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee reserved_names.end()) { 182236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name 182336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << " (" << FormatWordList(reserved_names) 182436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << " are reserved by " << GTEST_NAME_ << ")"; 1825fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 1826fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1827fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 1828fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1829fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 183036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Adds a failure if the key is a reserved attribute of the element named 183136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// xml_element. Returns true if the property is valid. 183236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leebool TestResult::ValidateTestProperty(const std::string& xml_element, 183336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const TestProperty& test_property) { 183436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ValidateTestPropertyName(test_property.key(), 183536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GetReservedAttributesForElement(xml_element)); 183636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 183736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 1838fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Clears the object. 1839fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestResult::Clear() { 1840fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_part_results_.clear(); 1841fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_properties_.clear(); 1842fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt death_test_count_ = 0; 1843fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt elapsed_time_ = 0; 1844fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1845fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1846fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test failed. 1847fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool TestResult::Failed() const { 1848fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < total_part_count(); ++i) { 1849fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GetTestPartResult(i).failed()) 1850fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 1851fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 1852fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 1853fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1854fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1855fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test part fatally failed. 1856fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool TestPartFatallyFailed(const TestPartResult& result) { 1857fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return result.fatally_failed(); 1858fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1859fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1860fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test fatally failed. 1861fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool TestResult::HasFatalFailure() const { 1862fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_part_results_, TestPartFatallyFailed) > 0; 1863fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1864fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1865fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test part non-fatally failed. 1866fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool TestPartNonfatallyFailed(const TestPartResult& result) { 1867fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return result.nonfatally_failed(); 1868fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1869fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1870fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the test has a non-fatal failure. 1871fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool TestResult::HasNonfatalFailure() const { 1872fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; 1873fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1874fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1875fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all test parts. This is the sum of the number 1876fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// of successful test parts and the number of failed test parts. 1877fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestResult::total_part_count() const { 1878fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<int>(test_part_results_.size()); 1879fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1880fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1881fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the number of the test properties. 1882fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestResult::test_property_count() const { 1883fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<int>(test_properties_.size()); 1884fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1885fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1886fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class Test 1887fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1888fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates a Test object. 1889fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1890fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The c'tor saves the values of all Google Test flags. 1891fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTest::Test() 1892fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : gtest_flag_saver_(new internal::GTestFlagSaver) { 1893fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1894fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1895fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The d'tor restores the values of all Google Test flags. 1896fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTest::~Test() { 1897fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete gtest_flag_saver_; 1898fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1899fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1900fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Sets up the test fixture. 1901fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 1902fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A sub-class may override this. 1903fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid Test::SetUp() { 1904fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1905fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1906fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Tears down the test fixture. 1907fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 1908fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A sub-class may override this. 1909fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid Test::TearDown() { 1910fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1911fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1912fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Allows user supplied key value pairs to be recorded for later output. 191336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid Test::RecordProperty(const std::string& key, const std::string& value) { 191436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee UnitTest::GetInstance()->RecordProperty(key, value); 1915fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1916fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1917fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Allows user supplied key value pairs to be recorded for later output. 191836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid Test::RecordProperty(const std::string& key, int value) { 1919fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message value_message; 1920fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt value_message << value; 1921fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt RecordProperty(key, value_message.GetString().c_str()); 1922fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1923fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1924fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 1925fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1926fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ReportFailureInUnknownLocation(TestPartResult::Type result_type, 192736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& message) { 1928fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This function is a friend of UnitTest and as such has access to 1929fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // AddTestPartResult. 1930fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTest::GetInstance()->AddTestPartResult( 1931fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result_type, 1932fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt NULL, // No info about the source file where the exception occurred. 1933fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt -1, // We have no info on which line caused the exception. 1934fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt message, 193536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ""); // No stack trace, either. 1936fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 1937fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1938fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 1939fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1940fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Google Test requires all tests in the same test case to use the same test 1941fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// fixture class. This function checks if the current test has the 1942fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// same fixture class as the first test in the current test case. If 1943fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// yes, it returns true; otherwise it generates a Google Test failure and 1944fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// returns false. 1945fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool Test::HasSameFixtureClass() { 1946fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 1947fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestCase* const test_case = impl->current_test_case(); 1948fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1949fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Info about the first test in the current test case. 1950fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestInfo* const first_test_info = test_case->test_info_list()[0]; 1951fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; 1952fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const first_test_name = first_test_info->name(); 1953fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1954fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Info about the current test. 1955fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestInfo* const this_test_info = impl->current_test_info(); 1956fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; 1957fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const this_test_name = this_test_info->name(); 1958fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1959fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (this_fixture_id != first_fixture_id) { 1960fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Is the first test defined using TEST? 1961fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); 1962fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Is this test defined using TEST? 1963fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); 1964fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1965fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (first_is_TEST || this_is_TEST) { 1966fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The user mixed TEST and TEST_F in this test case - we'll tell 1967fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // him/her how to fix it. 1968fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1969fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the name of the TEST and the name of the TEST_F. Note 1970fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // that first_is_TEST and this_is_TEST cannot both be true, as 1971fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // the fixture IDs are different for the two tests. 1972fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const TEST_name = 1973fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt first_is_TEST ? first_test_name : this_test_name; 1974fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const TEST_F_name = 1975fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt first_is_TEST ? this_test_name : first_test_name; 1976fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 1977fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ADD_FAILURE() 1978fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "All tests in the same test case must use the same test fixture\n" 1979fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "class, so mixing TEST_F and TEST in the same test case is\n" 1980fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "illegal. In test case " << this_test_info->test_case_name() 1981fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << ",\n" 1982fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "test " << TEST_F_name << " is defined using TEST_F but\n" 1983fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "test " << TEST_name << " is defined using TEST. You probably\n" 1984fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "want to change the TEST to TEST_F or move it to another test\n" 1985fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "case."; 1986fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 1987fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The user defined two fixture classes with the same name in 1988fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // two namespaces - we'll tell him/her how to fix it. 1989fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ADD_FAILURE() 1990fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "All tests in the same test case must use the same test fixture\n" 1991fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "class. However, in test case " 1992fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << this_test_info->test_case_name() << ",\n" 1993fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "you defined test " << first_test_name 1994fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " and test " << this_test_name << "\n" 1995fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "using two different test fixture classes. This can happen if\n" 1996fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "the two classes are from different namespaces or translation\n" 1997fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "units and have the same name. You should probably rename one\n" 1998fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "of the classes to put the tests into different test cases."; 1999fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2000fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 2001fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2002fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2003fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 2004fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2005fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2006fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_SEH 2007fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2008fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Adds an "exception thrown" fatal failure to the current test. This 2009fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// function returns its result via an output parameter pointer because VC++ 2010fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// prohibits creation of objects with destructors on stack in functions 2011fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// using __try (see error C2712). 201236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string* FormatSehExceptionMessage(DWORD exception_code, 201336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* location) { 2014fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message message; 2015fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt message << "SEH exception with code 0x" << std::setbase(16) << 2016fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exception_code << std::setbase(10) << " thrown in " << location << "."; 2017fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 201836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return new std::string(message.GetString()); 2019fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2020fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2021fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_SEH 2022fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 202336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leenamespace internal { 202436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 2025fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_EXCEPTIONS 2026fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2027fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Adds an "exception thrown" fatal failure to the current test. 202836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string FormatCxxExceptionMessage(const char* description, 202936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* location) { 2030fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message message; 2031fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (description != NULL) { 2032fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt message << "C++ exception with description \"" << description << "\""; 2033fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 2034fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt message << "Unknown C++ exception"; 2035fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2036fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt message << " thrown in " << location << "."; 2037fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2038fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return message.GetString(); 2039fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2040fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 204136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string PrintTestPartResultToString( 2042fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& test_part_result); 2043fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 204436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeGoogleTestFailureException::GoogleTestFailureException( 204536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const TestPartResult& failure) 204636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} 204736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 2048fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_EXCEPTIONS 2049fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2050fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// We put these helper functions in the internal namespace as IBM's xlC 2051fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// compiler rejects the code if they were declared static. 2052fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2053fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Runs the given method and handles SEH exceptions it throws, when 2054fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// SEH is supported; returns the 0-value for type Result in case of an 2055fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// SEH exception. (Microsoft compilers cannot handle SEH and C++ 2056fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// exceptions in the same function. Therefore, we provide a separate 2057fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// wrapper function for handling SEH exceptions.) 2058fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <class T, typename Result> 2059fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtResult HandleSehExceptionsInMethodIfSupported( 2060fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt T* object, Result (T::*method)(), const char* location) { 2061fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_SEH 2062fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt __try { 2063fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (object->*method)(); 2064fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT 2065fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetExceptionCode())) { 2066fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We create the exception message on the heap because VC++ prohibits 2067fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // creation of objects with destructors on stack in functions using __try 2068fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // (see error C2712). 206936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string* exception_message = FormatSehExceptionMessage( 2070fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetExceptionCode(), location); 2071fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, 2072fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *exception_message); 2073fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete exception_message; 2074fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<Result>(0); 2075fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2076fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2077fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (void)location; 2078fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (object->*method)(); 2079fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_SEH 2080fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2081fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2082fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Runs the given method and catches and reports C++ and/or SEH-style 2083fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// exceptions, if they are supported; returns the 0-value for type 2084fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Result in case of an SEH exception. 2085fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <class T, typename Result> 2086fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtResult HandleExceptionsInMethodIfSupported( 2087fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt T* object, Result (T::*method)(), const char* location) { 2088fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // NOTE: The user code can affect the way in which Google Test handles 2089fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 2090fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // RUN_ALL_TESTS() starts. It is technically possible to check the flag 2091fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // after the exception is caught and either report or re-throw the 2092fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // exception based on the flag's value: 2093fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 2094fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // try { 2095fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // // Perform the test method. 2096fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // } catch (...) { 2097fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // if (GTEST_FLAG(catch_exceptions)) 2098fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // // Report the exception as failure. 2099fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // else 2100fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // throw; // Re-throws the original exception. 2101fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // } 2102fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 2103fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // However, the purpose of this flag is to allow the program to drop into 2104fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // the debugger when the exception is thrown. On most platforms, once the 2105fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // control enters the catch block, the exception origin information is 2106fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // lost and the debugger will stop the program at the point of the 2107fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // re-throw in this function -- instead of at the point of the original 2108fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // throw statement in the code under test. For this reason, we perform 2109fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // the check early, sacrificing the ability to affect Google Test's 2110fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // exception handling in the method where the exception is thrown. 2111fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (internal::GetUnitTestImpl()->catch_exceptions()) { 2112fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_EXCEPTIONS 2113fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt try { 2114fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return HandleSehExceptionsInMethodIfSupported(object, method, location); 211536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } catch (const internal::GoogleTestFailureException&) { // NOLINT 211636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // This exception type can only be thrown by a failed Google 211736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // Test assertion with the intention of letting another testing 211836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // framework catch it. Therefore we just re-throw it. 2119fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt throw; 2120fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } catch (const std::exception& e) { // NOLINT 2121fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::ReportFailureInUnknownLocation( 2122fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResult::kFatalFailure, 2123fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatCxxExceptionMessage(e.what(), location)); 2124fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } catch (...) { // NOLINT 2125fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::ReportFailureInUnknownLocation( 2126fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResult::kFatalFailure, 2127fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatCxxExceptionMessage(NULL, location)); 2128fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2129fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<Result>(0); 2130fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2131fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return HandleSehExceptionsInMethodIfSupported(object, method, location); 2132fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_EXCEPTIONS 2133fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 2134fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (object->*method)(); 2135fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2136fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2137fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2138fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 2139fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2140fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Runs the test and updates the test result. 2141fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid Test::Run() { 2142fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!HasSameFixtureClass()) return; 2143fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2144fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2145fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2146fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); 2147fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We will run the test only if SetUp() was successful. 2148fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!HasFatalFailure()) { 2149fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2150fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::HandleExceptionsInMethodIfSupported( 2151fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt this, &Test::TestBody, "the test body"); 2152fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2153fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2154fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // However, we want to clean up as much as possible. Hence we will 2155fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // always call TearDown(), even if SetUp() or the test body has 2156fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // failed. 2157fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2158fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::HandleExceptionsInMethodIfSupported( 2159fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt this, &Test::TearDown, "TearDown()"); 2160fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2161fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2162fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the current test has a fatal failure. 2163fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool Test::HasFatalFailure() { 2164fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); 2165fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2166fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2167fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the current test has a non-fatal failure. 2168fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool Test::HasNonfatalFailure() { 2169fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return internal::GetUnitTestImpl()->current_test_result()-> 2170fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt HasNonfatalFailure(); 2171fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2172fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2173fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class TestInfo 2174fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2175fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Constructs a TestInfo object. It assumes ownership of the test factory 2176fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// object. 217736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeTestInfo::TestInfo(const std::string& a_test_case_name, 217836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& a_name, 2179fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* a_type_param, 2180fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* a_value_param, 2181fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::TypeId fixture_class_id, 2182fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::TestFactoryBase* factory) 2183fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : test_case_name_(a_test_case_name), 2184fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt name_(a_name), 2185fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt type_param_(a_type_param ? new std::string(a_type_param) : NULL), 2186fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt value_param_(a_value_param ? new std::string(a_value_param) : NULL), 2187fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fixture_class_id_(fixture_class_id), 2188fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt should_run_(false), 2189fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt is_disabled_(false), 2190fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt matches_filter_(false), 2191fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt factory_(factory), 2192fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result_() {} 2193fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2194fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Destructs a TestInfo object. 2195fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestInfo::~TestInfo() { delete factory_; } 2196fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2197fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 2198fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2199fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates a new TestInfo object and registers it with Google Test; 2200fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// returns the created object. 2201fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2202fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Arguments: 2203fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2204fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// test_case_name: name of the test case 2205fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// name: name of the test 2206fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// type_param: the name of the test's type parameter, or NULL if 2207fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// this is not a typed or a type-parameterized test. 2208fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value_param: text representation of the test's value parameter, 2209fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// or NULL if this is not a value-parameterized test. 2210fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// fixture_class_id: ID of the test fixture class 2211fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// set_up_tc: pointer to the function that sets up the test case 2212fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// tear_down_tc: pointer to the function that tears down the test case 2213fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// factory: pointer to the factory that creates a test object. 2214fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The newly created TestInfo instance will assume 2215fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// ownership of the factory object. 2216fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestInfo* MakeAndRegisterTestInfo( 221736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* test_case_name, 221836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* name, 2219fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* type_param, 2220fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* value_param, 2221fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TypeId fixture_class_id, 2222fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SetUpTestCaseFunc set_up_tc, 2223fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TearDownTestCaseFunc tear_down_tc, 2224fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestFactoryBase* factory) { 2225fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestInfo* const test_info = 2226fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt new TestInfo(test_case_name, name, type_param, value_param, 2227fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fixture_class_id, factory); 2228fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); 2229fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_info; 2230fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2231fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2232fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_PARAM_TEST 2233fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ReportInvalidTestCaseType(const char* test_case_name, 2234fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* file, int line) { 2235fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message errors; 2236fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt errors 2237fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Attempted redefinition of test case " << test_case_name << ".\n" 2238fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "All tests in the same test case must use the same test fixture\n" 2239fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "class. However, in test case " << test_case_name << ", you tried\n" 2240fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "to define a test using a fixture class different from the one\n" 2241fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "used earlier. This can happen if the two fixture classes are\n" 2242fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "from different namespaces and have the same name. You should\n" 2243fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "probably rename one of the classes to put the tests into different\n" 2244fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "test cases."; 2245fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2246fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), 2247fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt errors.GetString().c_str()); 2248fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2249fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_PARAM_TEST 2250fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2251fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 2252fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2253fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace { 2254fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2255fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A predicate that checks the test name of a TestInfo against a known 2256fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value. 2257fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2258fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This is used for implementation of the TestCase class only. We put 2259fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// it in the anonymous namespace to prevent polluting the outer 2260fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// namespace. 2261fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2262fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TestNameIs is copyable. 2263fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtclass TestNameIs { 2264fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt public: 2265fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Constructor. 2266fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 2267fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TestNameIs has NO default constructor. 2268fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt explicit TestNameIs(const char* name) 2269fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : name_(name) {} 2270fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2271fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns true iff the test name of test_info matches name_. 2272fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool operator()(const TestInfo * test_info) const { 227336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return test_info && test_info->name() == name_; 2274fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2275fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2276fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt private: 227736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string name_; 2278fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt}; 2279fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2280fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace 2281fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2282fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 2283fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2284fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This method expands all parameterized tests registered with macros TEST_P 2285fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// and INSTANTIATE_TEST_CASE_P into regular tests and registers those. 2286fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This will be done just once during the program runtime. 2287fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::RegisterParameterizedTests() { 2288fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_PARAM_TEST 2289fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!parameterized_tests_registered_) { 2290fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt parameterized_test_registry_.RegisterTests(); 2291fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt parameterized_tests_registered_ = true; 2292fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2293fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 2294fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2295fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2296fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 2297fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2298fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates the test object, runs it, records its result, and then 2299fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// deletes it. 2300fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestInfo::Run() { 2301fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!should_run_) return; 2302fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2303fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Tells UnitTest where to store test result. 2304fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2305fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->set_current_test_info(this); 2306fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2307fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 2308fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2309fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Notifies the unit test event listeners that a test is about to start. 2310fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestStart(*this); 2311fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2312fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TimeInMillis start = internal::GetTimeInMillis(); 2313fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2314fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2315fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2316fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Creates the test object. 2317fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Test* const test = internal::HandleExceptionsInMethodIfSupported( 2318fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt factory_, &internal::TestFactoryBase::CreateTest, 2319fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "the test fixture's constructor"); 2320fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2321fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Runs the test only if the test object was created and its 2322fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // constructor didn't generate a fatal failure. 2323fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if ((test != NULL) && !Test::HasFatalFailure()) { 2324fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This doesn't throw as all user code that can throw are wrapped into 2325fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // exception handling code. 2326fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test->Run(); 2327fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2328fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2329fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Deletes the test object. 2330fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2331fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::HandleExceptionsInMethodIfSupported( 2332fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test, &Test::DeleteSelf_, "the test fixture's destructor"); 2333fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2334fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result_.set_elapsed_time(internal::GetTimeInMillis() - start); 2335fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2336fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Notifies the unit test event listener that a test has just finished. 2337fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestEnd(*this); 2338fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2339fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Tells UnitTest to stop associating assertion results to this 2340fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // test. 2341fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->set_current_test_info(NULL); 2342fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2343fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2344fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class TestCase 2345fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2346fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of successful tests in this test case. 2347fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestCase::successful_test_count() const { 2348fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_info_list_, TestPassed); 2349fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2350fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2351fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of failed tests in this test case. 2352fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestCase::failed_test_count() const { 2353fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_info_list_, TestFailed); 2354fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2355fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 235636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of disabled tests that will be reported in the XML report. 235736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeint TestCase::reportable_disabled_test_count() const { 235836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return CountIf(test_info_list_, TestReportableDisabled); 235936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 236036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 236136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of disabled tests in this test case. 2362fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestCase::disabled_test_count() const { 2363fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_info_list_, TestDisabled); 2364fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2365fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 236636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of tests to be printed in the XML report. 236736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeint TestCase::reportable_test_count() const { 236836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return CountIf(test_info_list_, TestReportable); 236936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 237036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 2371fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Get the number of tests in this test case that should run. 2372fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestCase::test_to_run_count() const { 2373fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return CountIf(test_info_list_, ShouldRunTest); 2374fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2375fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2376fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all tests. 2377fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint TestCase::total_test_count() const { 2378fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return static_cast<int>(test_info_list_.size()); 2379fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2380fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2381fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates a TestCase with the given name. 2382fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2383fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Arguments: 2384fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2385fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// name: name of the test case 2386fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// a_type_param: the name of the test case's type parameter, or NULL if 2387fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// this is not a typed or a type-parameterized test case. 2388fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// set_up_tc: pointer to the function that sets up the test case 2389fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// tear_down_tc: pointer to the function that tears down the test case 2390fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestCase::TestCase(const char* a_name, const char* a_type_param, 2391fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Test::SetUpTestCaseFunc set_up_tc, 2392fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Test::TearDownTestCaseFunc tear_down_tc) 2393fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : name_(a_name), 2394fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt type_param_(a_type_param ? new std::string(a_type_param) : NULL), 2395fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt set_up_tc_(set_up_tc), 2396fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt tear_down_tc_(tear_down_tc), 2397fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt should_run_(false), 2398fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt elapsed_time_(0) { 2399fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2400fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2401fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Destructor of TestCase. 2402fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestCase::~TestCase() { 2403fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Deletes every Test in the collection. 2404fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ForEach(test_info_list_, internal::Delete<TestInfo>); 2405fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2406fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2407fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the i-th test among all the tests. i can range from 0 to 2408fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// total_test_count() - 1. If i is not in that range, returns NULL. 2409fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst TestInfo* TestCase::GetTestInfo(int i) const { 2410fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int index = GetElementOr(test_indices_, i, -1); 2411fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return index < 0 ? NULL : test_info_list_[index]; 2412fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2413fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2414fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the i-th test among all the tests. i can range from 0 to 2415fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// total_test_count() - 1. If i is not in that range, returns NULL. 2416fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestInfo* TestCase::GetMutableTestInfo(int i) { 2417fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int index = GetElementOr(test_indices_, i, -1); 2418fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return index < 0 ? NULL : test_info_list_[index]; 2419fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2420fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2421fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Adds a test to this test case. Will delete the test upon 2422fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// destruction of the TestCase object. 2423fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestCase::AddTestInfo(TestInfo * test_info) { 2424fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_info_list_.push_back(test_info); 2425fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_indices_.push_back(static_cast<int>(test_indices_.size())); 2426fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2427fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2428fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Runs every test in this TestCase. 2429fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestCase::Run() { 2430fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!should_run_) return; 2431fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2432fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2433fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->set_current_test_case(this); 2434fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2435fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 2436fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2437fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestCaseStart(*this); 2438fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2439fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::HandleExceptionsInMethodIfSupported( 2440fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); 2441fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2442fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const internal::TimeInMillis start = internal::GetTimeInMillis(); 2443fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < total_test_count(); i++) { 2444fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetMutableTestInfo(i)->Run(); 2445fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2446fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt elapsed_time_ = internal::GetTimeInMillis() - start; 2447fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2448fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->os_stack_trace_getter()->UponLeavingGTest(); 2449fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::HandleExceptionsInMethodIfSupported( 2450fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); 2451fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2452fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestCaseEnd(*this); 2453fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl->set_current_test_case(NULL); 2454fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2455fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2456fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Clears the results of all tests in this test case. 2457fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestCase::ClearResult() { 245836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ad_hoc_test_result_.Clear(); 2459fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ForEach(test_info_list_, TestInfo::ClearTestResult); 2460fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2461fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2462fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Shuffles the tests in this test case. 2463fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestCase::ShuffleTests(internal::Random* random) { 2464fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Shuffle(random, &test_indices_); 2465fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2466fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2467fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Restores the test order to before the first shuffle. 2468fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestCase::UnshuffleTests() { 2469fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < test_indices_.size(); i++) { 2470fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_indices_[i] = static_cast<int>(i); 2471fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2472fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2473fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2474fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Formats a countable noun. Depending on its quantity, either the 2475fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// singular form or the plural form is used. e.g. 2476fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2477fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// FormatCountableNoun(1, "formula", "formuli") returns "1 formula". 2478fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// FormatCountableNoun(5, "book", "books") returns "5 books". 247936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string FormatCountableNoun(int count, 248036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char * singular_form, 248136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char * plural_form) { 248236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return internal::StreamableToString(count) + " " + 248336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee (count == 1 ? singular_form : plural_form); 2484fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2485fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2486fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Formats the count of tests. 248736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string FormatTestCount(int test_count) { 2488fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return FormatCountableNoun(test_count, "test", "tests"); 2489fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2490fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2491fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Formats the count of test cases. 249236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string FormatTestCaseCount(int test_case_count) { 2493fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return FormatCountableNoun(test_case_count, "test case", "test cases"); 2494fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2495fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2496fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Converts a TestPartResult::Type enum to human-friendly string 2497fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// representation. Both kNonFatalFailure and kFatalFailure are translated 2498fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// to "Failure", as the user usually doesn't care about the difference 2499fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// between the two when viewing the test result. 2500fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char * TestPartResultTypeToString(TestPartResult::Type type) { 2501fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt switch (type) { 2502fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case TestPartResult::kSuccess: 2503fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return "Success"; 2504fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2505fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case TestPartResult::kNonFatalFailure: 2506fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case TestPartResult::kFatalFailure: 2507fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#ifdef _MSC_VER 2508fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return "error: "; 2509fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2510fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return "Failure\n"; 2511fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 2512fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default: 2513fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return "Unknown result type"; 2514fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2515fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2516fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 251736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leenamespace internal { 251836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 251936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Prints a TestPartResult to an std::string. 252036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic std::string PrintTestPartResultToString( 2521fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& test_part_result) { 2522fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (Message() 2523fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << internal::FormatFileLocation(test_part_result.file_name(), 2524fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_part_result.line_number()) 2525fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " " << TestPartResultTypeToString(test_part_result.type()) 2526fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << test_part_result.message()).GetString(); 2527fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2528fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2529fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Prints a TestPartResult. 2530fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic void PrintTestPartResult(const TestPartResult& test_part_result) { 253136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& result = 2532fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrintTestPartResultToString(test_part_result); 2533fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s\n", result.c_str()); 2534fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2535fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // If the test program runs in Visual Studio or a debugger, the 2536fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // following statements add the test part result message to the Output 2537fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // window such that the user can double-click on it to jump to the 2538fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // corresponding source code location; otherwise they do nothing. 2539fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2540fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We don't call OutputDebugString*() on Windows Mobile, as printing 2541fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // to stdout is done by OutputDebugString() there already - we don't 2542fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // want the same message printed twice. 2543fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ::OutputDebugStringA(result.c_str()); 2544fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ::OutputDebugStringA("\n"); 2545fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 2546fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2547fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2548fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class PrettyUnitTestResultPrinter 2549fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2550fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtenum GTestColor { 2551fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt COLOR_DEFAULT, 2552fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt COLOR_RED, 2553fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt COLOR_GREEN, 2554fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt COLOR_YELLOW 2555fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt}; 2556fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2557fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2558fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2559fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the character attribute for the given color. 2560fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtWORD GetColorAttribute(GTestColor color) { 2561fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt switch (color) { 2562fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case COLOR_RED: return FOREGROUND_RED; 2563fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case COLOR_GREEN: return FOREGROUND_GREEN; 2564fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; 2565fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default: return 0; 2566fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2567fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2568fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2569fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2570fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2571fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the ANSI color code for the given color. COLOR_DEFAULT is 2572fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// an invalid input. 2573fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst char* GetAnsiColorCode(GTestColor color) { 2574fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt switch (color) { 2575fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case COLOR_RED: return "1"; 2576fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case COLOR_GREEN: return "2"; 2577fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case COLOR_YELLOW: return "3"; 2578fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default: return NULL; 2579fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt }; 2580fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2581fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2582fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2583fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2584fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff Google Test should use colors in the output. 2585fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool ShouldUseColor(bool stdout_is_tty) { 2586fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const gtest_color = GTEST_FLAG(color).c_str(); 2587fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2588fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { 2589fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS 2590fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // On Windows the TERM variable is usually not set, but the 2591fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // console there does support colors. 2592fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return stdout_is_tty; 2593fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2594fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // On non-Windows platforms, we rely on the TERM variable. 2595fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const term = posix::GetEnv("TERM"); 2596fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool term_supports_color = 2597fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(term, "xterm") || 2598fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(term, "xterm-color") || 2599fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(term, "xterm-256color") || 2600fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(term, "screen") || 260136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee String::CStringEquals(term, "screen-256color") || 2602fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(term, "linux") || 2603fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(term, "cygwin"); 2604fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return stdout_is_tty && term_supports_color; 2605fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS 2606fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2607fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2608fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || 2609fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CaseInsensitiveCStringEquals(gtest_color, "true") || 2610fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CaseInsensitiveCStringEquals(gtest_color, "t") || 2611fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt String::CStringEquals(gtest_color, "1"); 2612fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We take "yes", "true", "t", and "1" as meaning "yes". If the 2613fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // value is neither one of these nor "auto", we treat it as "no" to 2614fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // be conservative. 2615fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2616fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2617fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helpers for printing colored strings to stdout. Note that on Windows, we 2618fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// cannot simply emit special characters and have the terminal change colors. 2619fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This routine must actually emit the characters rather than return a string 2620fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// that would be colored when printed, as can be done on Linux. 2621fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ColoredPrintf(GTestColor color, const char* fmt, ...) { 2622fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt va_list args; 2623fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt va_start(args, fmt); 2624fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 262536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || GTEST_OS_IOS 2626fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool use_color = false; 2627fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2628fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static const bool in_color_mode = 2629fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); 2630fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool use_color = in_color_mode && (color != COLOR_DEFAULT); 2631fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS 2632fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The '!= 0' comparison is necessary to satisfy MSVC 7.1. 2633fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2634fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!use_color) { 2635fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt vprintf(fmt, args); 2636fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt va_end(args); 2637fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return; 2638fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2639fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2640fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2641fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); 2642fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2643fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the current text color. 2644fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt CONSOLE_SCREEN_BUFFER_INFO buffer_info; 2645fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); 2646fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const WORD old_color_attrs = buffer_info.wAttributes; 2647fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2648fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We need to flush the stream buffers into the console before each 2649fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // SetConsoleTextAttribute call lest it affect the text that is already 2650fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // printed but has not yet reached the console. 2651fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2652fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SetConsoleTextAttribute(stdout_handle, 2653fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetColorAttribute(color) | FOREGROUND_INTENSITY); 2654fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt vprintf(fmt, args); 2655fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2656fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2657fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Restores the text color. 2658fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SetConsoleTextAttribute(stdout_handle, old_color_attrs); 2659fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 2660fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\033[0;3%sm", GetAnsiColorCode(color)); 2661fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt vprintf(fmt, args); 2662fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\033[m"); // Resets the terminal to default. 2663fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 2664fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt va_end(args); 2665fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2666fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 266736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Text printed in Google Test's text output and --gunit_list_tests 266836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// output to label the type parameter and value parameter for a test. 266936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic const char kTypeParamLabel[] = "TypeParam"; 267036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic const char kValueParamLabel[] = "GetParam()"; 267136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 2672fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrintFullTestCommentIfPresent(const TestInfo& test_info) { 2673fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const type_param = test_info.type_param(); 2674fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const value_param = test_info.value_param(); 2675fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2676fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (type_param != NULL || value_param != NULL) { 2677fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf(", where "); 2678fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (type_param != NULL) { 267936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("%s = %s", kTypeParamLabel, type_param); 2680fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (value_param != NULL) 2681fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf(" and "); 2682fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2683fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (value_param != NULL) { 268436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("%s = %s", kValueParamLabel, value_param); 2685fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2686fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2687fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2688fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2689fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This class implements the TestEventListener interface. 2690fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2691fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Class PrettyUnitTestResultPrinter is copyable. 2692fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtclass PrettyUnitTestResultPrinter : public TestEventListener { 2693fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt public: 2694fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrettyUnitTestResultPrinter() {} 2695fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static void PrintTestName(const char * test_case, const char * test) { 2696fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s.%s", test_case, test); 2697fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2698fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2699fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The following methods override what's in the TestEventListener class. 2700fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} 2701fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); 2702fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); 2703fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} 2704fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestCaseStart(const TestCase& test_case); 2705fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestStart(const TestInfo& test_info); 2706fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestPartResult(const TestPartResult& result); 2707fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestEnd(const TestInfo& test_info); 2708fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestCaseEnd(const TestCase& test_case); 2709fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); 2710fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} 2711fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 2712fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} 2713fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2714fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt private: 2715fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static void PrintFailedTests(const UnitTest& unit_test); 2716fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt}; 2717fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2718fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Fired before each iteration of tests starts. 2719fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestIterationStart( 2720fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const UnitTest& unit_test, int iteration) { 2721fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(repeat) != 1) 2722fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); 2723fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2724fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const filter = GTEST_FLAG(filter).c_str(); 2725fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2726fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Prints the filter if it's not *. This reminds the user that some 2727fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // tests may be skipped. 272836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (!String::CStringEquals(filter, kUniversalFilter)) { 2729fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_YELLOW, 2730fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Note: %s filter = %s\n", GTEST_NAME_, filter); 2731fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2732fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2733fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { 2734fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); 2735fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_YELLOW, 2736fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Note: This is test shard %d of %s.\n", 2737fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static_cast<int>(shard_index) + 1, 2738fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::posix::GetEnv(kTestTotalShards)); 2739fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2740fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2741fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(shuffle)) { 2742fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_YELLOW, 2743fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Note: Randomizing tests' orders with a seed of %d .\n", 2744fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt unit_test.random_seed()); 2745fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2746fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2747fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[==========] "); 2748fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("Running %s from %s.\n", 2749fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatTestCount(unit_test.test_to_run_count()).c_str(), 2750fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); 2751fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2752fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2753fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2754fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( 2755fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const UnitTest& /*unit_test*/) { 2756fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[----------] "); 2757fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("Global test environment set-up.\n"); 2758fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2759fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2760fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2761fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { 276236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string counts = 2763fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 2764fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[----------] "); 276536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("%s from %s", counts.c_str(), test_case.name()); 2766fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_case.type_param() == NULL) { 2767fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n"); 2768fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 276936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); 2770fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2771fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2772fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2773fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2774fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { 2775fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[ RUN ] "); 277636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintTestName(test_info.test_case_name(), test_info.name()); 2777fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n"); 2778fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2779fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2780fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2781fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Called after an assertion failure. 2782fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestPartResult( 2783fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& result) { 2784fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // If the test part succeeded, we don't need to do anything. 2785fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (result.type() == TestPartResult::kSuccess) 2786fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return; 2787fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2788fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Print failure message from the assertion (e.g. expected this and got that). 2789fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrintTestPartResult(result); 2790fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2791fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2792fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2793fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { 2794fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_info.result()->Passed()) { 2795fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[ OK ] "); 2796fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 2797fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, "[ FAILED ] "); 2798fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 279936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintTestName(test_info.test_case_name(), test_info.name()); 2800fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_info.result()->Failed()) 2801fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrintFullTestCommentIfPresent(test_info); 2802fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2803fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(print_time)) { 2804fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf(" (%s ms)\n", internal::StreamableToString( 2805fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_info.result()->elapsed_time()).c_str()); 2806fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 2807fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n"); 2808fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2809fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2810fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2811fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2812fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { 2813fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!GTEST_FLAG(print_time)) return; 2814fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 281536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string counts = 2816fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 2817fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[----------] "); 2818fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s from %s (%s ms total)\n\n", 281936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee counts.c_str(), test_case.name(), 2820fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StreamableToString(test_case.elapsed_time()).c_str()); 2821fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2822fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2823fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2824fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( 2825fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const UnitTest& /*unit_test*/) { 2826fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[----------] "); 2827fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("Global test environment tear-down\n"); 2828fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2829fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2830fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2831fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Internal helper for printing the list of failed tests. 2832fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { 2833fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int failed_test_count = unit_test.failed_test_count(); 2834fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (failed_test_count == 0) { 2835fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return; 2836fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2837fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2838fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < unit_test.total_test_case_count(); ++i) { 2839fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestCase& test_case = *unit_test.GetTestCase(i); 2840fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { 2841fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt continue; 2842fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2843fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int j = 0; j < test_case.total_test_count(); ++j) { 2844fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestInfo& test_info = *test_case.GetTestInfo(j); 2845fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!test_info.should_run() || test_info.result()->Passed()) { 2846fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt continue; 2847fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2848fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, "[ FAILED ] "); 2849fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s.%s", test_case.name(), test_info.name()); 2850fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrintFullTestCommentIfPresent(test_info); 2851fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n"); 2852fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2853fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2854fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2855fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2856fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 2857fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int /*iteration*/) { 2858fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[==========] "); 2859fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s from %s ran.", 2860fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatTestCount(unit_test.test_to_run_count()).c_str(), 2861fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); 2862fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(print_time)) { 2863fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf(" (%s ms total)", 2864fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::StreamableToString(unit_test.elapsed_time()).c_str()); 2865fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2866fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n"); 2867fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); 2868fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); 2869fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2870fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int num_failures = unit_test.failed_test_count(); 2871fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!unit_test.Passed()) { 2872fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int failed_test_count = unit_test.failed_test_count(); 2873fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, "[ FAILED ] "); 2874fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); 2875fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrintFailedTests(unit_test); 2876fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n%2d FAILED %s\n", num_failures, 2877fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_failures == 1 ? "TEST" : "TESTS"); 2878fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2879fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 288036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee int num_disabled = unit_test.reportable_disabled_test_count(); 2881fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { 2882fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!num_failures) { 2883fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("\n"); // Add a spacer if no FAILURE banner is displayed. 2884fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2885fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_YELLOW, 2886fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt " YOU HAVE %d DISABLED %s\n\n", 2887fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_disabled, 2888fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_disabled == 1 ? "TEST" : "TESTS"); 2889fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2890fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Ensure that Google Test output is printed before, e.g., heapchecker output. 2891fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 2892fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2893fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2894fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// End PrettyUnitTestResultPrinter 2895fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2896fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class TestEventRepeater 2897fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 2898fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This class forwards events to other event listeners. 2899fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtclass TestEventRepeater : public TestEventListener { 2900fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt public: 2901fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestEventRepeater() : forwarding_enabled_(true) {} 2902fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual ~TestEventRepeater(); 2903fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt void Append(TestEventListener *listener); 2904fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestEventListener* Release(TestEventListener* listener); 2905fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2906fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Controls whether events will be forwarded to listeners_. Set to false 2907fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // in death test child processes. 2908fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool forwarding_enabled() const { return forwarding_enabled_; } 2909fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } 2910fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2911fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestProgramStart(const UnitTest& unit_test); 2912fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); 2913fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); 2914fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); 2915fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestCaseStart(const TestCase& test_case); 2916fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestStart(const TestInfo& test_info); 2917fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestPartResult(const TestPartResult& result); 2918fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestEnd(const TestInfo& test_info); 2919fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestCaseEnd(const TestCase& test_case); 2920fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); 2921fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); 2922fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 2923fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestProgramEnd(const UnitTest& unit_test); 2924fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2925fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt private: 2926fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Controls whether events will be forwarded to listeners_. Set to false 2927fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // in death test child processes. 2928fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool forwarding_enabled_; 2929fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The list of listeners that receive events. 2930fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt std::vector<TestEventListener*> listeners_; 2931fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2932fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); 2933fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt}; 2934fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2935fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventRepeater::~TestEventRepeater() { 2936fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ForEach(listeners_, Delete<TestEventListener>); 2937fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2938fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2939fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventRepeater::Append(TestEventListener *listener) { 2940fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners_.push_back(listener); 2941fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2942fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2943fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(vladl@google.com): Factor the search functionality into Vector::Find. 2944fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventListener* TestEventRepeater::Release(TestEventListener *listener) { 2945fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < listeners_.size(); ++i) { 2946fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (listeners_[i] == listener) { 2947fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners_.erase(listeners_.begin() + i); 2948fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return listener; 2949fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2950fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2951fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2952fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return NULL; 2953fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2954fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2955fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Since most methods are very similar, use macros to reduce boilerplate. 2956fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This defines a member that forwards the call to all listeners. 2957fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#define GTEST_REPEATER_METHOD_(Name, Type) \ 2958fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventRepeater::Name(const Type& parameter) { \ 2959fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (forwarding_enabled_) { \ 2960fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < listeners_.size(); i++) { \ 2961fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners_[i]->Name(parameter); \ 2962fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } \ 2963fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } \ 2964fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2965fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This defines a member that forwards the call to all listeners in reverse 2966fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// order. 2967fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ 2968fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventRepeater::Name(const Type& parameter) { \ 2969fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (forwarding_enabled_) { \ 2970fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \ 2971fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners_[i]->Name(parameter); \ 2972fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } \ 2973fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } \ 2974fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2975fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2976fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) 2977fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) 2978fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) 2979fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REPEATER_METHOD_(OnTestStart, TestInfo) 2980fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) 2981fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) 2982fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) 2983fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) 2984fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) 2985fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) 2986fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtGTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) 2987fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2988fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#undef GTEST_REPEATER_METHOD_ 2989fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#undef GTEST_REVERSE_REPEATER_METHOD_ 2990fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 2991fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, 2992fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int iteration) { 2993fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (forwarding_enabled_) { 2994fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < listeners_.size(); i++) { 2995fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners_[i]->OnTestIterationStart(unit_test, iteration); 2996fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2997fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 2998fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 2999fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3000fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, 3001fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int iteration) { 3002fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (forwarding_enabled_) { 3003fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { 3004fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners_[i]->OnTestIterationEnd(unit_test, iteration); 3005fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3006fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3007fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3008fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3009fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// End TestEventRepeater 3010fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3011fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This class generates an XML output file. 3012fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtclass XmlUnitTestResultPrinter : public EmptyTestEventListener { 3013fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt public: 3014fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt explicit XmlUnitTestResultPrinter(const char* output_file); 3015fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3016fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 3017fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3018fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt private: 3019fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Is c a whitespace character that is normalized to a space character 3020fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // when it appears in an XML attribute value? 3021fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static bool IsNormalizableWhitespace(char c) { 3022fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return c == 0x9 || c == 0xA || c == 0xD; 3023fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3024fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3025fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // May c appear in a well-formed XML document? 3026fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static bool IsValidXmlCharacter(char c) { 3027fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return IsNormalizableWhitespace(c) || c >= 0x20; 3028fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3029fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3030fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns an XML-escaped copy of the input string str. If 3031fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // is_attribute is true, the text is meant to appear as an attribute 3032fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // value, and normalizable whitespace is preserved by replacing it 3033fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // with character references. 303436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static std::string EscapeXml(const std::string& str, bool is_attribute); 3035fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3036fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns the given string with all characters invalid in XML removed. 303736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static std::string RemoveInvalidXmlCharacters(const std::string& str); 3038fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3039fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Convenience wrapper around EscapeXml when str is an attribute value. 304036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static std::string EscapeXmlAttribute(const std::string& str) { 3041fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return EscapeXml(str, true); 3042fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3043fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3044fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Convenience wrapper around EscapeXml when str is not an attribute value. 304536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static std::string EscapeXmlText(const char* str) { 304636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return EscapeXml(str, false); 304736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 304836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 304936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // Verifies that the given attribute belongs to the given element and 305036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // streams the attribute as XML. 305136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static void OutputXmlAttribute(std::ostream* stream, 305236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& element_name, 305336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& name, 305436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& value); 3055fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3056fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. 3057fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static void OutputXmlCDataSection(::std::ostream* stream, const char* data); 3058fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3059fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Streams an XML representation of a TestInfo object. 3060fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static void OutputXmlTestInfo(::std::ostream* stream, 3061fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* test_case_name, 3062fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestInfo& test_info); 3063fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3064fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Prints an XML representation of a TestCase object 306536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static void PrintXmlTestCase(::std::ostream* stream, 306636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const TestCase& test_case); 3067fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3068fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Prints an XML summary of unit_test to output stream out. 306936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static void PrintXmlUnitTest(::std::ostream* stream, 307036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const UnitTest& unit_test); 3071fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3072fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Produces a string representing the test properties in a result as space 3073fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // delimited XML attributes based on the property key="value" pairs. 307436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // When the std::string is not empty, it includes a space at the beginning, 3075fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // to delimit this attribute from prior attributes. 307636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee static std::string TestPropertiesAsXmlAttributes(const TestResult& result); 3077fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3078fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The output file. 307936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string output_file_; 3080fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3081fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); 3082fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt}; 3083fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3084fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates a new XmlUnitTestResultPrinter. 3085fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtXmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) 3086fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : output_file_(output_file) { 3087fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (output_file_.c_str() == NULL || output_file_.empty()) { 3088fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fprintf(stderr, "XML output file may not be null\n"); 3089fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stderr); 3090fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 3091fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3092fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3093fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3094fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Called after the unit test ends. 3095fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 3096fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int /*iteration*/) { 3097fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FILE* xmlout = NULL; 3098fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FilePath output_file(output_file_); 3099fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FilePath output_dir(output_file.RemoveFileName()); 3100fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3101fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (output_dir.CreateDirectoriesRecursively()) { 3102fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt xmlout = posix::FOpen(output_file_.c_str(), "w"); 3103fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3104fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (xmlout == NULL) { 3105fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TODO(wan): report the reason of the failure. 3106fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 3107fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We don't do it for now as: 3108fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 3109fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 1. There is no urgent need for it. 3110fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 2. It's a bit involved to make the errno variable thread-safe on 3111fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // all three operating systems (Linux, Windows, and Mac OS). 3112fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 3. To interpret the meaning of errno in a thread-safe way, 3113fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // we need the strerror_r() function, which is not available on 3114fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Windows. 3115fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fprintf(stderr, 3116fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Unable to open file \"%s\"\n", 3117fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output_file_.c_str()); 3118fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stderr); 3119fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 3120fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 312136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::stringstream stream; 312236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintXmlUnitTest(&stream, unit_test); 312336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); 3124fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fclose(xmlout); 3125fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3126fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3127fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns an XML-escaped copy of the input string str. If is_attribute 3128fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// is true, the text is meant to appear as an attribute value, and 3129fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// normalizable whitespace is preserved by replacing it with character 3130fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// references. 3131fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3132fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Invalid XML characters in str, if any, are stripped from the output. 3133fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// It is expected that most, if not all, of the text processed by this 3134fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// module will consist of ordinary English text. 3135fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// If this module is ever modified to produce version 1.1 XML output, 3136fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// most invalid characters can be retained using character references. 3137fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(wan): It might be nice to have a minimally invasive, human-readable 3138fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// escaping scheme for invalid characters, rather than dropping them. 313936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string XmlUnitTestResultPrinter::EscapeXml( 314036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& str, bool is_attribute) { 3141fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message m; 3142fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 314336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee for (size_t i = 0; i < str.size(); ++i) { 314436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char ch = str[i]; 314536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee switch (ch) { 314636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee case '<': 314736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << "<"; 314836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 314936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee case '>': 315036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << ">"; 315136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 315236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee case '&': 315336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << "&"; 315436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 315536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee case '\'': 315636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (is_attribute) 315736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << "'"; 315836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee else 315936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << '\''; 316036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 316136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee case '"': 316236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (is_attribute) 316336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << """; 316436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee else 316536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << '"'; 316636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 316736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee default: 316836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (IsValidXmlCharacter(ch)) { 316936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (is_attribute && IsNormalizableWhitespace(ch)) 317036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch)) 317136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << ";"; 3172fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt else 317336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee m << ch; 317436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 317536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 3176fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3177fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3178fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3179fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return m.GetString(); 3180fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3181fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3182fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the given string with all characters invalid in XML removed. 3183fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Currently invalid characters are dropped from the string. An 3184fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// alternative is to replace them with certain characters such as . or ?. 318536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters( 318636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& str) { 318736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string output; 3188fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output.reserve(str.size()); 318936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) 3190fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (IsValidXmlCharacter(*it)) 3191fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output.push_back(*it); 3192fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3193fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return output; 3194fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3195fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3196fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The following routines generate an XML representation of a UnitTest 3197fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// object. 3198fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3199fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This is how Google Test concepts map to the DTD: 3200fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3201fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <testsuites name="AllTests"> <-- corresponds to a UnitTest object 3202fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <testsuite name="testcase-name"> <-- corresponds to a TestCase object 3203fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <testcase name="test-name"> <-- corresponds to a TestInfo object 3204fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <failure message="...">...</failure> 3205fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <failure message="...">...</failure> 3206fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <failure message="...">...</failure> 3207fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// <-- individual assertion failures 3208fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// </testcase> 3209fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// </testsuite> 3210fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// </testsuites> 3211fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3212fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Formats the given time in milliseconds as seconds. 3213fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstd::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { 3214fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ::std::stringstream ss; 3215fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ss << ms/1000.0; 3216fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return ss.str(); 3217fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3218fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 321936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Converts the given epoch time in milliseconds to a date string in the ISO 322036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// 8601 format, without the timezone information. 322136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) { 322236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // Using non-reentrant version as localtime_r is not portable. 322336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee time_t seconds = static_cast<time_t>(ms / 1000); 322436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#ifdef _MSC_VER 322536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee# pragma warning(push) // Saves the current warning state. 322636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee# pragma warning(disable:4996) // Temporarily disables warning 4996 322736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // (function or variable may be unsafe). 322836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const struct tm* const time_struct = localtime(&seconds); // NOLINT 322936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee# pragma warning(pop) // Restores the warning state again. 323036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#else 323136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const struct tm* const time_struct = localtime(&seconds); // NOLINT 323236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee#endif 323336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (time_struct == NULL) 323436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ""; // Invalid ms value 323536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 323636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // YYYY-MM-DDThh:mm:ss 323736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return StreamableToString(time_struct->tm_year + 1900) + "-" + 323836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee String::FormatIntWidth2(time_struct->tm_mon + 1) + "-" + 323936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee String::FormatIntWidth2(time_struct->tm_mday) + "T" + 324036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee String::FormatIntWidth2(time_struct->tm_hour) + ":" + 324136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee String::FormatIntWidth2(time_struct->tm_min) + ":" + 324236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee String::FormatIntWidth2(time_struct->tm_sec); 324336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 324436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3245fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Streams an XML CDATA section, escaping invalid CDATA sequences as needed. 3246fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, 3247fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* data) { 3248fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* segment = data; 3249fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << "<![CDATA["; 3250fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (;;) { 3251fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const next_segment = strstr(segment, "]]>"); 3252fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (next_segment != NULL) { 3253fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt stream->write( 3254fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt segment, static_cast<std::streamsize>(next_segment - segment)); 3255fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << "]]>]]><![CDATA["; 3256fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt segment = next_segment + strlen("]]>"); 3257fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 3258fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << segment; 3259fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt break; 3260fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3261fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3262fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << "]]>"; 3263fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3264fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 326536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid XmlUnitTestResultPrinter::OutputXmlAttribute( 326636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::ostream* stream, 326736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& element_name, 326836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& name, 326936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& value) { 327036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::vector<std::string>& allowed_names = 327136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GetReservedAttributesForElement(element_name); 327236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 327336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != 327436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee allowed_names.end()) 327536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << "Attribute " << name << " is not allowed for element <" << element_name 327636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << ">."; 327736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 327836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\""; 327936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 328036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3281fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Prints an XML representation of a TestInfo object. 3282fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(wan): There is also value in printing properties with the plain printer. 3283fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, 3284fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* test_case_name, 3285fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestInfo& test_info) { 3286fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestResult& result = *test_info.result(); 328736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string kTestcase = "testcase"; 328836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 328936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << " <testcase"; 329036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestcase, "name", test_info.name()); 3291fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3292fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_info.value_param() != NULL) { 329336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestcase, "value_param", 329436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee test_info.value_param()); 3295fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3296fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_info.type_param() != NULL) { 329736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param()); 3298fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3299fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 330036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestcase, "status", 330136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee test_info.should_run() ? "run" : "notrun"); 330236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestcase, "time", 330336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee FormatTimeInMillisAsSeconds(result.elapsed_time())); 330436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestcase, "classname", test_case_name); 330536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << TestPropertiesAsXmlAttributes(result); 3306fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3307fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int failures = 0; 3308fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < result.total_part_count(); ++i) { 3309fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult& part = result.GetTestPartResult(i); 3310fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (part.failed()) { 331136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (++failures == 1) { 3312fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << ">\n"; 331336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 3314fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const string location = internal::FormatCompilerIndependentFileLocation( 3315fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt part.file_name(), part.line_number()); 331636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const string summary = location + "\n" + part.summary(); 331736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << " <failure message=\"" 331836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << EscapeXmlAttribute(summary.c_str()) 331936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << "\" type=\"\">"; 332036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const string detail = location + "\n" + part.message(); 332136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); 3322fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << "</failure>\n"; 3323fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3324fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3325fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3326fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (failures == 0) 3327fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << " />\n"; 3328fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt else 3329fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *stream << " </testcase>\n"; 3330fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3331fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3332fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Prints an XML representation of a TestCase object 333336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream, 3334fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestCase& test_case) { 333536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string kTestsuite = "testsuite"; 333636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << " <" << kTestsuite; 333736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuite, "name", test_case.name()); 333836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuite, "tests", 333936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(test_case.reportable_test_count())); 334036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuite, "failures", 334136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(test_case.failed_test_count())); 334236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute( 334336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee stream, kTestsuite, "disabled", 334436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(test_case.reportable_disabled_test_count())); 334536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuite, "errors", "0"); 334636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuite, "time", 334736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee FormatTimeInMillisAsSeconds(test_case.elapsed_time())); 334836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result()) 334936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee << ">\n"; 335036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3351fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < test_case.total_test_count(); ++i) { 335236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (test_case.GetTestInfo(i)->is_reportable()) 335336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i)); 3354fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 335536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << " </" << kTestsuite << ">\n"; 3356fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3357fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3358fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Prints an XML summary of unit_test to output stream out. 335936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream, 3360fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const UnitTest& unit_test) { 336136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string kTestsuites = "testsuites"; 336236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 336336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; 336436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << "<" << kTestsuites; 336536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 336636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuites, "tests", 336736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(unit_test.reportable_test_count())); 336836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuites, "failures", 336936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(unit_test.failed_test_count())); 337036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute( 337136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee stream, kTestsuites, "disabled", 337236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(unit_test.reportable_disabled_test_count())); 337336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuites, "errors", "0"); 337436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute( 337536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee stream, kTestsuites, "timestamp", 337636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp())); 337736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuites, "time", 337836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee FormatTimeInMillisAsSeconds(unit_test.elapsed_time())); 337936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3380fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(shuffle)) { 338136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuites, "random_seed", 338236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee StreamableToString(unit_test.random_seed())); 338336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 338436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 338536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result()); 338636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 338736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); 338836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << ">\n"; 338936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 339036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee for (int i = 0; i < unit_test.total_test_case_count(); ++i) { 339136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (unit_test.GetTestCase(i)->reportable_test_count() > 0) 339236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintXmlTestCase(stream, *unit_test.GetTestCase(i)); 3393fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 339436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee *stream << "</" << kTestsuites << ">\n"; 3395fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3396fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3397fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Produces a string representing the test properties in a result as space 3398fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// delimited XML attributes based on the property key="value" pairs. 339936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( 3400fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestResult& result) { 3401fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message attributes; 3402fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i < result.test_property_count(); ++i) { 3403fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestProperty& property = result.GetTestProperty(i); 3404fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt attributes << " " << property.key() << "=" 3405fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "\"" << EscapeXmlAttribute(property.value()) << "\""; 3406fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3407fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return attributes.GetString(); 3408fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3409fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3410fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// End XmlUnitTestResultPrinter 3411fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3412fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_CAN_STREAM_RESULTS_ 3413fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3414fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Checks if str contains '=', '&', '%' or '\n' characters. If yes, 3415fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// replaces them by "%xx" where xx is their hexadecimal value. For 3416fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// example, replaces "=" with "%3D". This algorithm is O(strlen(str)) 3417fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// in both time and space -- important as the input str may contain an 3418fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// arbitrarily long test failure message and stack trace. 3419fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstring StreamingListener::UrlEncode(const char* str) { 3420fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt string result; 3421fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result.reserve(strlen(str) + 1); 3422fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (char ch = *str; ch != '\0'; ch = *++str) { 3423fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt switch (ch) { 3424fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '%': 3425fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '=': 3426fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '&': 3427fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt case '\n': 342836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee result.append("%" + String::FormatByte(static_cast<unsigned char>(ch))); 3429fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt break; 3430fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default: 3431fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt result.push_back(ch); 3432fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt break; 3433fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3434fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3435fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return result; 3436fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3437fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 343836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid StreamingListener::SocketWriter::MakeConnection() { 3439fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_CHECK_(sockfd_ == -1) 3440fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "MakeConnection() can't be called when there is already a connection."; 3441fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3442fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt addrinfo hints; 3443fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt memset(&hints, 0, sizeof(hints)); 3444fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. 3445fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt hints.ai_socktype = SOCK_STREAM; 3446fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt addrinfo* servinfo = NULL; 3447fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3448fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Use the getaddrinfo() to get a linked list of IP addresses for 3449fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // the given host name. 3450fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int error_num = getaddrinfo( 3451fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); 3452fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (error_num != 0) { 3453fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " 3454fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << gai_strerror(error_num); 3455fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3456fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3457fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Loop through all the results and connect to the first we can. 3458fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; 3459fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt cur_addr = cur_addr->ai_next) { 3460fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt sockfd_ = socket( 3461fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); 3462fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (sockfd_ != -1) { 3463fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Connect the client socket to the server socket. 3464fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { 3465fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt close(sockfd_); 3466fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt sockfd_ = -1; 3467fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3468fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3469fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3470fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3471fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt freeaddrinfo(servinfo); // all done with this structure 3472fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3473fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (sockfd_ == -1) { 3474fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " 3475fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << host_name_ << ":" << port_num_; 3476fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3477fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3478fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3479fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// End of class Streaming Listener 3480fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_CAN_STREAM_RESULTS__ 3481fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3482fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Class ScopedTrace 3483fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3484fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Pushes the given source file location and message onto a per-thread 3485fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// trace stack maintained by Google Test. 348636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeScopedTrace::ScopedTrace(const char* file, int line, const Message& message) 348736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { 3488fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TraceInfo trace; 3489fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt trace.file = file; 3490fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt trace.line = line; 3491fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt trace.message = message.GetString(); 3492fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3493fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTest::GetInstance()->PushGTestTrace(trace); 3494fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3495fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3496fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Pops the info pushed by the c'tor. 349736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeScopedTrace::~ScopedTrace() 349836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { 3499fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTest::GetInstance()->PopGTestTrace(); 3500fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3501fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3502fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3503fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class OsStackTraceGetter 3504fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 350536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Returns the current OS stack trace as an std::string. Parameters: 3506fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3507fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// max_depth - the maximum number of stack frames to be included 3508fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// in the trace. 3509fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// skip_count - the number of top frames to be skipped; doesn't count 3510fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// against max_depth. 3511fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 351236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestring OsStackTraceGetter::CurrentStackTrace(int /* max_depth */, 351336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee int /* skip_count */) 351436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 351536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return ""; 3516fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3517fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 351836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid OsStackTraceGetter::UponLeavingGTest() 351936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 3520fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3521fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3522fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst char* const 3523fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtOsStackTraceGetter::kElidedFramesMarker = 3524fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "... " GTEST_NAME_ " internal frames ..."; 3525fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 352636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// A helper class that creates the premature-exit file in its 352736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// constructor and deletes the file in its destructor. 352836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeclass ScopedPrematureExitFile { 352936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee public: 353036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee explicit ScopedPrematureExitFile(const char* premature_exit_filepath) 353136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee : premature_exit_filepath_(premature_exit_filepath) { 353236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // If a path to the premature-exit file is specified... 353336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') { 353436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // create the file with a single "0" character in it. I/O 353536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // errors are ignored as there's nothing better we can do and we 353636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // don't want to fail the test because of this. 353736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee FILE* pfile = posix::FOpen(premature_exit_filepath, "w"); 353836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee fwrite("0", 1, 1, pfile); 353936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee fclose(pfile); 354036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 354136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 354236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 354336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ~ScopedPrematureExitFile() { 354436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') { 354536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee remove(premature_exit_filepath_); 354636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 354736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 354836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 354936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee private: 355036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* const premature_exit_filepath_; 355136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 355236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile); 355336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee}; 355436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3555fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 3556fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3557fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class TestEventListeners 3558fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3559fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventListeners::TestEventListeners() 3560fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : repeater_(new internal::TestEventRepeater()), 3561fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_result_printer_(NULL), 3562fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_xml_generator_(NULL) { 3563fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3564fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3565fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventListeners::~TestEventListeners() { delete repeater_; } 3566fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3567fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the standard listener responsible for the default console 3568fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// output. Can be removed from the listeners list to shut down default 3569fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// console output. Note that removing this object from the listener list 3570fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// with Release transfers its ownership to the user. 3571fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventListeners::Append(TestEventListener* listener) { 3572fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater_->Append(listener); 3573fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3574fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3575fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Removes the given event listener from the list and returns it. It then 3576fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// becomes the caller's responsibility to delete the listener. Returns 3577fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// NULL if the listener is not found in the list. 3578fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventListener* TestEventListeners::Release(TestEventListener* listener) { 3579fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (listener == default_result_printer_) 3580fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_result_printer_ = NULL; 3581fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt else if (listener == default_xml_generator_) 3582fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_xml_generator_ = NULL; 3583fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return repeater_->Release(listener); 3584fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3585fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3586fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns repeater that broadcasts the TestEventListener events to all 3587fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// subscribers. 3588fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventListener* TestEventListeners::repeater() { return repeater_; } 3589fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3590fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Sets the default_result_printer attribute to the provided listener. 3591fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The listener is also added to the listener list and previous 3592fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// default_result_printer is removed from it and deleted. The listener can 3593fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// also be NULL in which case it will not be added to the list. Does 3594fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// nothing if the previous and the current listener objects are the same. 3595fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { 3596fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (default_result_printer_ != listener) { 3597fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // It is an error to pass this method a listener that is already in the 3598fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // list. 3599fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete Release(default_result_printer_); 3600fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_result_printer_ = listener; 3601fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (listener != NULL) 3602fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Append(listener); 3603fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3604fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3605fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3606fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Sets the default_xml_generator attribute to the provided listener. The 3607fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// listener is also added to the listener list and previous 3608fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// default_xml_generator is removed from it and deleted. The listener can 3609fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// also be NULL in which case it will not be added to the list. Does 3610fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// nothing if the previous and the current listener objects are the same. 3611fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { 3612fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (default_xml_generator_ != listener) { 3613fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // It is an error to pass this method a listener that is already in the 3614fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // list. 3615fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete Release(default_xml_generator_); 3616fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_xml_generator_ = listener; 3617fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (listener != NULL) 3618fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Append(listener); 3619fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3620fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3621fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3622fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Controls whether events will be forwarded by the repeater to the 3623fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// listeners in the list. 3624fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool TestEventListeners::EventForwardingEnabled() const { 3625fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return repeater_->forwarding_enabled(); 3626fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3627fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3628fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid TestEventListeners::SuppressEventForwarding() { 3629fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater_->set_forwarding_enabled(false); 3630fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3631fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3632fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// class UnitTest 3633fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3634fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the singleton UnitTest object. The first time this method is 3635fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// called, a UnitTest object is constructed and returned. Consecutive 3636fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// calls will return the same object. 3637fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3638fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// We don't protect this under mutex_ as a user is not supposed to 3639fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// call this before main() starts, from which point on the return 3640fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value will never change. 364136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson LeeUnitTest* UnitTest::GetInstance() { 3642fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // When compiled with MSVC 7.1 in optimized mode, destroying the 3643fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // UnitTest object upon exiting the program messes up the exit code, 3644fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // causing successful tests to appear failed. We have to use a 3645fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // different implementation in this case to bypass the compiler bug. 3646fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This implementation makes the compiler happy, at the cost of 3647fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // leaking the UnitTest object. 3648fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3649fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // CodeGear C++Builder insists on a public destructor for the 3650fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // default implementation. Use this implementation to keep good OO 3651fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // design with private destructor. 3652fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3653fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) 3654fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static UnitTest* const instance = new UnitTest; 3655fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return instance; 3656fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 3657fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static UnitTest instance; 3658fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return &instance; 3659fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) 3660fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3661fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3662fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of successful test cases. 3663fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::successful_test_case_count() const { 3664fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->successful_test_case_count(); 3665fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3666fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3667fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of failed test cases. 3668fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::failed_test_case_count() const { 3669fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->failed_test_case_count(); 3670fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3671fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3672fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all test cases. 3673fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::total_test_case_count() const { 3674fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->total_test_case_count(); 3675fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3676fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3677fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all test cases that contain at least one test 3678fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// that should run. 3679fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::test_case_to_run_count() const { 3680fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->test_case_to_run_count(); 3681fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3682fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3683fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of successful tests. 3684fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::successful_test_count() const { 3685fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->successful_test_count(); 3686fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3687fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3688fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of failed tests. 3689fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::failed_test_count() const { return impl()->failed_test_count(); } 3690fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 369136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of disabled tests that will be reported in the XML report. 369236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeint UnitTest::reportable_disabled_test_count() const { 369336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return impl()->reportable_disabled_test_count(); 369436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 369536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3696fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of disabled tests. 3697fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::disabled_test_count() const { 3698fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->disabled_test_count(); 3699fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3700fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 370136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the number of tests to be printed in the XML report. 370236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeint UnitTest::reportable_test_count() const { 370336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return impl()->reportable_test_count(); 370436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 370536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3706fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of all tests. 3707fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::total_test_count() const { return impl()->total_test_count(); } 3708fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3709fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the number of tests that should run. 3710fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } 3711fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 371236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Gets the time of the test program start, in ms from the start of the 371336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// UNIX epoch. 371436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeinternal::TimeInMillis UnitTest::start_timestamp() const { 371536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return impl()->start_timestamp(); 371636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 371736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3718fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the elapsed time, in milliseconds. 3719fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtinternal::TimeInMillis UnitTest::elapsed_time() const { 3720fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->elapsed_time(); 3721fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3722fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3723fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the unit test passed (i.e. all test cases passed). 3724fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool UnitTest::Passed() const { return impl()->Passed(); } 3725fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3726fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns true iff the unit test failed (i.e. some test case failed 3727fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// or something outside of all tests failed). 3728fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool UnitTest::Failed() const { return impl()->Failed(); } 3729fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3730fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the i-th test case among all the test cases. i can range from 0 to 3731fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// total_test_case_count() - 1. If i is not in that range, returns NULL. 3732fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst TestCase* UnitTest::GetTestCase(int i) const { 3733fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->GetTestCase(i); 3734fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3735fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 373636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Returns the TestResult containing information on test failures and 373736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// properties logged outside of individual test cases. 373836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeconst TestResult& UnitTest::ad_hoc_test_result() const { 373936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee return *impl()->ad_hoc_test_result(); 374036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 374136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3742fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Gets the i-th test case among all the test cases. i can range from 0 to 3743fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// total_test_case_count() - 1. If i is not in that range, returns NULL. 3744fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestCase* UnitTest::GetMutableTestCase(int i) { 3745fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl()->GetMutableTestCase(i); 3746fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3747fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3748fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the list of event listeners that can be used to track events 3749fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// inside Google Test. 3750fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestEventListeners& UnitTest::listeners() { 3751fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *impl()->listeners(); 3752fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3753fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3754fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Registers and returns a global test environment. When a test 3755fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// program is run, all global test environments will be set-up in the 3756fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// order they were registered. After all tests in the program have 3757fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// finished, all global test environments will be torn-down in the 3758fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// *reverse* order they were registered. 3759fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3760fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The UnitTest object takes ownership of the given environment. 3761fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3762fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// We don't protect this under mutex_, as we only support calling it 3763fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// from the main thread. 3764fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtEnvironment* UnitTest::AddEnvironment(Environment* env) { 3765fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (env == NULL) { 3766fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return NULL; 3767fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3768fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3769fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl_->environments().push_back(env); 3770fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return env; 3771fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3772fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3773fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Adds a TestPartResult to the current TestResult object. All Google Test 3774fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call 3775fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// this to report their results. The user code should use the 3776fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// assertion macros instead of calling this directly. 377736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid UnitTest::AddTestPartResult( 377836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee TestPartResult::Type result_type, 377936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const char* file_name, 378036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee int line_number, 378136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& message, 378236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) { 3783fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Message msg; 3784fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << message; 3785fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3786fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&mutex_); 3787fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (impl_->gtest_trace_stack().size() > 0) { 3788fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\n" << GTEST_NAME_ << " trace:"; 3789fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3790fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = static_cast<int>(impl_->gtest_trace_stack().size()); 3791fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt i > 0; --i) { 3792fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; 3793fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) 3794fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << " " << trace.message; 3795fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3796fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3797fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3798fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { 3799fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg << internal::kStackTraceMarker << os_stack_trace; 3800fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3801fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3802fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestPartResult result = 3803fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestPartResult(result_type, file_name, line_number, 3804fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt msg.GetString().c_str()); 3805fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl_->GetTestPartResultReporterForCurrentThread()-> 3806fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ReportTestPartResult(result); 3807fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3808fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (result_type != TestPartResult::kSuccess) { 3809fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // gtest_break_on_failure takes precedence over 3810fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // gtest_throw_on_failure. This allows a user to set the latter 3811fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // in the code (perhaps in order to use Google Test assertions 3812fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // with another testing framework) and specify the former on the 3813fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // command line for debugging. 3814fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(break_on_failure)) { 3815fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_OS_WINDOWS 3816fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Using DebugBreak on Windows allows gtest to still break into a debugger 3817fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // when a failure happens and both the --gtest_break_on_failure and 3818fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // the --gtest_catch_exceptions flags are specified. 3819fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt DebugBreak(); 3820fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 3821fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Dereference NULL through a volatile pointer to prevent the compiler 3822fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // from removing. We use this rather than abort() or __builtin_trap() for 3823fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // portability: Symbian doesn't implement abort() well, and some debuggers 3824fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // don't correctly trap abort(). 3825fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *static_cast<volatile int*>(NULL) = 1; 3826fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_OS_WINDOWS 3827fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (GTEST_FLAG(throw_on_failure)) { 3828fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_EXCEPTIONS 382936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee throw internal::GoogleTestFailureException(result); 3830fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 3831fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We cannot call abort() as it generates a pop-up in debug mode 3832fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // that cannot be suppressed in VC 7.1 or below. 3833fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(1); 3834fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 3835fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3836fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3837fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3838fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 383936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Adds a TestProperty to the current TestResult object when invoked from 384036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// inside a test, to current TestCase's ad_hoc_test_result_ when invoked 384136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// from SetUpTestCase or TearDownTestCase, or to the global property set 384236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// when invoked elsewhere. If the result already contains a property with 384336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// the same key, the value will be updated. 384436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid UnitTest::RecordProperty(const std::string& key, 384536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& value) { 384636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee impl_->RecordProperty(TestProperty(key, value)); 3847fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3848fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3849fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Runs all tests in this UnitTest object and prints the result. 3850fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns 0 if successful, or 1 otherwise. 3851fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 3852fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// We don't protect this under mutex_, as we only support calling it 3853fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// from the main thread. 3854fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::Run() { 385536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const bool in_death_test_child_process = 385636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee internal::GTEST_FLAG(internal_run_death_test).length() > 0; 385736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 385836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // Google Test implements this protocol for catching that a test 385936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // program exits before returning control to Google Test: 386036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // 386136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // 1. Upon start, Google Test creates a file whose absolute path 386236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // is specified by the environment variable 386336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // TEST_PREMATURE_EXIT_FILE. 386436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // 2. When Google Test has finished its work, it deletes the file. 386536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // 386636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before 386736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // running a Google-Test-based test program and check the existence 386836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // of the file at the end of the test execution to see if it has 386936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // exited prematurely. 387036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 387136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // If we are in the child process of a death test, don't 387236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // create/delete the premature exit file, as doing so is unnecessary 387336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // and will confuse the parent process. Otherwise, create/delete 387436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // the file upon entering/leaving this function. If the program 387536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // somehow exits before this function has a chance to return, the 387636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // premature-exit file will be left undeleted, causing a test runner 387736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // that understands the premature-exit-file protocol to report the 387836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // test as having failed. 387936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const internal::ScopedPrematureExitFile premature_exit_file( 388036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee in_death_test_child_process ? 388136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); 388236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 3883fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Captures the value of GTEST_FLAG(catch_exceptions). This value will be 3884fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // used for the duration of the program. 3885fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); 3886fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3887fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_SEH 3888fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Either the user wants Google Test to catch exceptions thrown by the 3889fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // tests or this is executing in the context of death test child 3890fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // process. In either case the user does not want to see pop-up dialogs 3891fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // about crashes - they are expected. 3892fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (impl()->catch_exceptions() || in_death_test_child_process) { 3893fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# if !GTEST_OS_WINDOWS_MOBILE 3894fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // SetErrorMode doesn't exist on CE. 3895fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | 3896fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); 3897fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# endif // !GTEST_OS_WINDOWS_MOBILE 3898fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3899fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE 3900fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Death test children can be terminated with _abort(). On Windows, 3901fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // _abort() can show a dialog with a warning message. This forces the 3902fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // abort message to go to stderr instead. 3903fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt _set_error_mode(_OUT_TO_STDERR); 3904fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# endif 3905fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3906fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE 3907fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // In the debug version, Visual Studio pops up a separate dialog 3908fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // offering a choice to debug the aborted program. We need to suppress 3909fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement 3910fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // executed. Google Test will notify the user of any unexpected 3911fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // failure via stderr. 3912fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // 3913fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. 3914fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Users of prior VC versions shall suffer the agony and pain of 3915fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // clicking through the countless debug dialogs. 3916fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // TODO(vladl@google.com): find a way to suppress the abort dialog() in the 3917fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // debug mode when compiled with VC 7.1 or lower. 3918fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!GTEST_FLAG(break_on_failure)) 3919fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt _set_abort_behavior( 3920fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 0x0, // Clear the following flags: 3921fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. 3922fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# endif 3923fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 3924fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_SEH 3925fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3926fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return internal::HandleExceptionsInMethodIfSupported( 3927fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl(), 3928fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt &internal::UnitTestImpl::RunAllTests, 3929fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "auxiliary test code (environments or event listeners)") ? 0 : 1; 3930fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3931fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3932fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the working directory when the first TEST() or TEST_F() was 3933fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// executed. 3934fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst char* UnitTest::original_working_dir() const { 3935fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl_->original_working_dir_.c_str(); 3936fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3937fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3938fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the TestCase object for the test that's currently running, 3939fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// or NULL if no test is running. 394036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeconst TestCase* UnitTest::current_test_case() const 394136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 3942fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&mutex_); 3943fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl_->current_test_case(); 3944fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3945fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3946fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the TestInfo object for the test that's currently running, 3947fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// or NULL if no test is running. 394836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leeconst TestInfo* UnitTest::current_test_info() const 394936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 3950fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&mutex_); 3951fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl_->current_test_info(); 3952fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3953fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3954fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the random seed used at the start of the current test run. 3955fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTest::random_seed() const { return impl_->random_seed(); } 3956fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3957fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_PARAM_TEST 3958fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns ParameterizedTestCaseRegistry object used to keep track of 3959fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value-parameterized tests and instantiate and register them. 3960fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtinternal::ParameterizedTestCaseRegistry& 396136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee UnitTest::parameterized_test_registry() 396236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 3963fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return impl_->parameterized_test_registry(); 3964fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3965fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_PARAM_TEST 3966fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3967fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Creates an empty UnitTest. 3968fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUnitTest::UnitTest() { 3969fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl_ = new internal::UnitTestImpl(this); 3970fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3971fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3972fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Destructor of UnitTest. 3973fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUnitTest::~UnitTest() { 3974fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete impl_; 3975fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3976fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3977fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Pushes a trace defined by SCOPED_TRACE() on to the per-thread 3978fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Google Test trace stack. 397936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid UnitTest::PushGTestTrace(const internal::TraceInfo& trace) 398036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 3981fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&mutex_); 3982fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl_->gtest_trace_stack().push_back(trace); 3983fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3984fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3985fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Pops a trace from the per-thread Google Test trace stack. 398636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid UnitTest::PopGTestTrace() 398736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee GTEST_LOCK_EXCLUDED_(mutex_) { 3988fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::MutexLock lock(&mutex_); 3989fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt impl_->gtest_trace_stack().pop_back(); 3990fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 3991fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3992fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace internal { 3993fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 3994fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUnitTestImpl::UnitTestImpl(UnitTest* parent) 3995fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : parent_(parent), 3996fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#ifdef _MSC_VER 3997fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# pragma warning(push) // Saves the current warning state. 3998fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# pragma warning(disable:4355) // Temporarily disables warning 4355 3999fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // (using this in initializer). 4000fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_global_test_part_result_reporter_(this), 4001fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_per_thread_test_part_result_reporter_(this), 4002fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt# pragma warning(pop) // Restores the warning state again. 4003fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#else 4004fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_global_test_part_result_reporter_(this), 4005fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt default_per_thread_test_part_result_reporter_(this), 4006fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // _MSC_VER 4007fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt global_test_part_result_repoter_( 4008fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt &default_global_test_part_result_reporter_), 4009fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt per_thread_test_part_result_reporter_( 4010fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt &default_per_thread_test_part_result_reporter_), 4011fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_PARAM_TEST 4012fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt parameterized_test_registry_(), 4013fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt parameterized_tests_registered_(false), 4014fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_PARAM_TEST 4015fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt last_death_test_case_(-1), 4016fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt current_test_case_(NULL), 4017fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt current_test_info_(NULL), 4018fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ad_hoc_test_result_(), 4019fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt os_stack_trace_getter_(NULL), 4020fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt post_flag_parse_init_performed_(false), 4021fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt random_seed_(0), // Will be overridden by the flag before first use. 4022fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt random_(0), // Will be reseeded before first use. 402336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee start_timestamp_(0), 4024fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt elapsed_time_(0), 4025fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_DEATH_TEST 4026fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt death_test_factory_(new DefaultDeathTestFactory), 4027fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif 4028fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Will be overridden by the flag before first use. 4029fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt catch_exceptions_(false) { 4030fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); 4031fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4032fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4033fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtUnitTestImpl::~UnitTestImpl() { 4034fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Deletes every TestCase. 4035fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ForEach(test_cases_, internal::Delete<TestCase>); 4036fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4037fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Deletes every Environment. 4038fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ForEach(environments_, internal::Delete<Environment>); 4039fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4040fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete os_stack_trace_getter_; 4041fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4042fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 404336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Adds a TestProperty to the current TestResult object when invoked in a 404436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// context of a test, to current test case's ad_hoc_test_result when invoke 404536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// from SetUpTestCase/TearDownTestCase, or to the global property set 404636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// otherwise. If the result already contains a property with the same key, 404736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// the value will be updated. 404836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leevoid UnitTestImpl::RecordProperty(const TestProperty& test_property) { 404936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string xml_element; 405036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee TestResult* test_result; // TestResult appropriate for property recording. 405136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 405236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (current_test_info_ != NULL) { 405336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee xml_element = "testcase"; 405436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee test_result = &(current_test_info_->result_); 405536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else if (current_test_case_ != NULL) { 405636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee xml_element = "testsuite"; 405736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee test_result = &(current_test_case_->ad_hoc_test_result_); 405836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else { 405936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee xml_element = "testsuites"; 406036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee test_result = &ad_hoc_test_result_; 406136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 406236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee test_result->RecordProperty(xml_element, test_property); 406336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 406436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 4065fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_DEATH_TEST 4066fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Disables event forwarding if the control is currently in a death test 4067fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// subprocess. Must not be called before InitGoogleTest. 4068fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::SuppressTestEventsIfInSubprocess() { 4069fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (internal_run_death_test_flag_.get() != NULL) 4070fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners()->SuppressEventForwarding(); 4071fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4072fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_DEATH_TEST 4073fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4074fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Initializes event listeners performing XML output as specified by 4075fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// UnitTestOptions. Must not be called before InitGoogleTest. 4076fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::ConfigureXmlOutput() { 407736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& output_format = UnitTestOptions::GetOutputFormat(); 4078fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (output_format == "xml") { 4079fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( 4080fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); 4081fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (output_format != "") { 4082fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("WARNING: unrecognized output format \"%s\" ignored.\n", 4083fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt output_format.c_str()); 4084fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4085fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4086fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4087fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4088fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_CAN_STREAM_RESULTS_ 408936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Initializes event listeners for streaming test results in string form. 4090fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Must not be called before InitGoogleTest. 4091fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::ConfigureStreamingOutput() { 409236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string& target = GTEST_FLAG(stream_result_to); 4093fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!target.empty()) { 4094fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const size_t pos = target.find(':'); 409536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (pos != std::string::npos) { 4096fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt listeners()->Append(new StreamingListener(target.substr(0, pos), 4097fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt target.substr(pos+1))); 4098fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 4099fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", 4100fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt target.c_str()); 4101fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4102fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4103fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4104fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4105fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_CAN_STREAM_RESULTS_ 4106fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4107fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Performs initialization dependent upon flag values obtained in 4108fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to 4109fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest 4110fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// this function is also called from RunAllTests. Since this function can be 4111fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// called more than once, it has to be idempotent. 4112fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::PostFlagParsingInit() { 4113fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Ensures that this function does not execute more than once. 4114fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!post_flag_parse_init_performed_) { 4115fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt post_flag_parse_init_performed_ = true; 4116fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4117fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_DEATH_TEST 4118fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt InitDeathTestSubprocessControlInfo(); 4119fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SuppressTestEventsIfInSubprocess(); 4120fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_DEATH_TEST 4121fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4122fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Registers parameterized tests. This makes parameterized tests 4123fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // available to the UnitTest reflection API without running 4124fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // RUN_ALL_TESTS. 4125fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt RegisterParameterizedTests(); 4126fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4127fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Configures listeners for XML output. This makes it possible for users 4128fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // to shut down the default XML output before invoking RUN_ALL_TESTS. 4129fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ConfigureXmlOutput(); 4130fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4131fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_CAN_STREAM_RESULTS_ 4132fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Configures listeners for streaming test results to the specified server. 4133fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ConfigureStreamingOutput(); 4134fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_CAN_STREAM_RESULTS_ 4135fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4136fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4137fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4138fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// A predicate that checks the name of a TestCase against a known 4139fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// value. 4140fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4141fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This is used for implementation of the UnitTest class only. We put 4142fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// it in the anonymous namespace to prevent polluting the outer 4143fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// namespace. 4144fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4145fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TestCaseNameIs is copyable. 4146fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtclass TestCaseNameIs { 4147fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt public: 4148fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Constructor. 414936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee explicit TestCaseNameIs(const std::string& name) 4150fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : name_(name) {} 4151fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4152fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns true iff the name of test_case matches name_. 4153fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool operator()(const TestCase* test_case) const { 4154fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; 4155fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4156fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4157fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt private: 415836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee std::string name_; 4159fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt}; 4160fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4161fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Finds and returns a TestCase with the given name. If one doesn't 4162fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// exist, creates one and returns it. It's the CALLER'S 4163fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// RESPONSIBILITY to ensure that this function is only called WHEN THE 4164fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TESTS ARE NOT SHUFFLED. 4165fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4166fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Arguments: 4167fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4168fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// test_case_name: name of the test case 4169fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// type_param: the name of the test case's type parameter, or NULL if 4170fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// this is not a typed or a type-parameterized test case. 4171fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// set_up_tc: pointer to the function that sets up the test case 4172fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// tear_down_tc: pointer to the function that tears down the test case 4173fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestCase* UnitTestImpl::GetTestCase(const char* test_case_name, 4174fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* type_param, 4175fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Test::SetUpTestCaseFunc set_up_tc, 4176fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Test::TearDownTestCaseFunc tear_down_tc) { 4177fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Can we find a TestCase with the given name? 4178fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const std::vector<TestCase*>::const_iterator test_case = 4179fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt std::find_if(test_cases_.begin(), test_cases_.end(), 4180fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestCaseNameIs(test_case_name)); 4181fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4182fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_case != test_cases_.end()) 4183fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return *test_case; 4184fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4185fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // No. Let's create one. 4186fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestCase* const new_test_case = 4187fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); 4188fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4189fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Is this a death test case? 419036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (internal::UnitTestOptions::MatchesFilter(test_case_name, 4191fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt kDeathTestCaseFilter)) { 4192fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Yes. Inserts the test case after the last death test case 4193fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // defined so far. This only works when the test cases haven't 4194fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // been shuffled. Otherwise we may end up running a death test 4195fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // after a non-death test. 4196fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ++last_death_test_case_; 4197fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_cases_.insert(test_cases_.begin() + last_death_test_case_, 4198fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt new_test_case); 4199fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 4200fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // No. Appends to the end of the list. 4201fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_cases_.push_back(new_test_case); 4202fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4203fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4204fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_case_indices_.push_back(static_cast<int>(test_case_indices_.size())); 4205fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return new_test_case; 4206fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4207fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4208fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Helpers for setting up / tearing down the given environment. They 4209fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// are for use in the ForEach() function. 4210fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic void SetUpEnvironment(Environment* env) { env->SetUp(); } 4211fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic void TearDownEnvironment(Environment* env) { env->TearDown(); } 4212fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4213fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Runs all tests in this UnitTest object, prints the result, and 4214fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// returns true if all tests are successful. If any exception is 4215fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// thrown during a test, the test is considered to be failed, but the 4216fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// rest of the tests will still be run. 4217fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4218fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// When parameterized tests are enabled, it expands and registers 4219fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// parameterized tests first in RegisterParameterizedTests(). 4220fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// All other functions called from RunAllTests() may safely assume that 4221fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// parameterized tests are ready to be counted and run. 4222fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool UnitTestImpl::RunAllTests() { 4223fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Makes sure InitGoogleTest() was called. 4224fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!GTestIsInitialized()) { 4225fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printf("%s", 4226fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "\nThis test program did NOT call ::testing::InitGoogleTest " 4227fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "before calling RUN_ALL_TESTS(). Please fix it.\n"); 4228fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 4229fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4230fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4231fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Do not run any test if the --help flag was specified. 4232fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (g_help_flag) 4233fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 4234fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4235fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Repeats the call to the post-flag parsing initialization in case the 4236fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // user didn't call InitGoogleTest. 4237fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PostFlagParsingInit(); 4238fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4239fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Even if sharding is not on, test runners may want to use the 4240fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding 4241fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // protocol. 4242fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::WriteToShardStatusFileIfNeeded(); 4243fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4244fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // True iff we are in a subprocess for running a thread-safe-style 4245fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // death test. 4246fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool in_subprocess_for_death_test = false; 4247fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4248fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_DEATH_TEST 4249fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); 4250fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_DEATH_TEST 4251fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4252fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, 4253fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt in_subprocess_for_death_test); 4254fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4255fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Compares the full test names with the filter to decide which 4256fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // tests to run. 4257fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool has_tests_to_run = FilterTests(should_shard 4258fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ? HONOR_SHARDING_PROTOCOL 4259fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt : IGNORE_SHARDING_PROTOCOL) > 0; 4260fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4261fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Lists the tests and exits if the --gtest_list_tests flag was specified. 4262fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(list_tests)) { 4263fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This must be called *after* FilterTests() has been called. 4264fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ListTestsMatchingFilter(); 4265fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 4266fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4267fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4268fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt random_seed_ = GTEST_FLAG(shuffle) ? 4269fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; 4270fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4271fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // True iff at least one test has failed. 4272fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool failed = false; 4273fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4274fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestEventListener* repeater = listeners()->repeater(); 4275fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 427636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee start_timestamp_ = GetTimeInMillis(); 4277fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestProgramStart(*parent_); 4278fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4279fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // How many times to repeat the tests? We don't want to repeat them 4280fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // when we are inside the subprocess of a death test. 4281fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); 4282fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Repeats forever if the repeat count is negative. 4283fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool forever = repeat < 0; 4284fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; forever || i != repeat; i++) { 4285fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We want to preserve failures generated by ad-hoc test 4286fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // assertions executed before RUN_ALL_TESTS(). 4287fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ClearNonAdHocTestResult(); 4288fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4289fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TimeInMillis start = GetTimeInMillis(); 4290fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4291fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Shuffles test cases and tests if requested. 4292fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (has_tests_to_run && GTEST_FLAG(shuffle)) { 4293fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt random()->Reseed(random_seed_); 4294fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This should be done before calling OnTestIterationStart(), 4295fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // such that a test event listener can see the actual test order 4296fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // in the event. 4297fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ShuffleTests(); 4298fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4299fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4300fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Tells the unit test event listeners that the tests are about to start. 4301fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestIterationStart(*parent_, i); 4302fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4303fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Runs each test case if there is at least one test to run. 4304fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (has_tests_to_run) { 4305fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Sets up all environments beforehand. 4306fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnEnvironmentsSetUpStart(*parent_); 4307fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ForEach(environments_, SetUpEnvironment); 4308fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnEnvironmentsSetUpEnd(*parent_); 4309fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4310fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Runs the tests only if there was no fatal failure during global 4311fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // set-up. 4312fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!Test::HasFatalFailure()) { 4313fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int test_index = 0; test_index < total_test_case_count(); 4314fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_index++) { 4315fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetMutableTestCase(test_index)->Run(); 4316fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4317fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4318fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4319fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Tears down all environments in reverse order afterwards. 4320fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnEnvironmentsTearDownStart(*parent_); 4321fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt std::for_each(environments_.rbegin(), environments_.rend(), 4322fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TearDownEnvironment); 4323fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnEnvironmentsTearDownEnd(*parent_); 4324fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4325fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4326fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt elapsed_time_ = GetTimeInMillis() - start; 4327fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4328fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Tells the unit test event listener that the tests have just finished. 4329fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestIterationEnd(*parent_, i); 4330fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4331fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the result and clears it. 4332fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!Passed()) { 4333fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt failed = true; 4334fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4335fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4336fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Restores the original test order after the iteration. This 4337fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // allows the user to quickly repro a failure that happens in the 4338fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // N-th iteration without repeating the first (N - 1) iterations. 4339fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in 4340fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // case the user somehow changes the value of the flag somewhere 4341fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // (it's always safe to unshuffle the tests). 4342fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt UnshuffleTests(); 4343fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4344fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (GTEST_FLAG(shuffle)) { 4345fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Picks a new random seed for each iteration. 4346fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt random_seed_ = GetNextRandomSeed(random_seed_); 4347fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4348fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4349fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4350fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt repeater->OnTestProgramEnd(*parent_); 4351fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4352fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return !failed; 4353fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4354fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4355fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file 4356fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// if the variable is present. If a file already exists at this location, this 4357fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// function will write over it. If the variable is present, but the file cannot 4358fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// be created, prints an error and exits. 4359fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid WriteToShardStatusFileIfNeeded() { 4360fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); 4361fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_shard_file != NULL) { 4362fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt FILE* const file = posix::FOpen(test_shard_file, "w"); 4363fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (file == NULL) { 4364fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, 4365fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "Could not write to the test shard status file \"%s\" " 4366fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "specified by the %s environment variable.\n", 4367fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_shard_file, kTestShardStatusFile); 4368fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4369fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 4370fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4371fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fclose(file); 4372fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4373fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4374fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4375fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Checks whether sharding is enabled by examining the relevant 4376fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// environment variable values. If the variables are present, 4377fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// but inconsistent (i.e., shard_index >= total_shards), prints 4378fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// an error and exits. If in_subprocess_for_death_test, sharding is 4379fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// disabled because it must only be applied to the original test 4380fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// process. Otherwise, we could filter out death tests we intended to execute. 4381fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool ShouldShard(const char* total_shards_env, 4382fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* shard_index_env, 4383fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool in_subprocess_for_death_test) { 4384fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (in_subprocess_for_death_test) { 4385fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 4386fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4387fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4388fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); 4389fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); 4390fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4391fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (total_shards == -1 && shard_index == -1) { 4392fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 4393fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (total_shards == -1 && shard_index != -1) { 4394fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Message msg = Message() 4395fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Invalid environment variables: you have " 4396fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << kTestShardIndex << " = " << shard_index 4397fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << ", but have left " << kTestTotalShards << " unset.\n"; 4398fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 4399fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4400fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 4401fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (total_shards != -1 && shard_index == -1) { 4402fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Message msg = Message() 4403fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Invalid environment variables: you have " 4404fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << kTestTotalShards << " = " << total_shards 4405fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << ", but have left " << kTestShardIndex << " unset.\n"; 4406fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 4407fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4408fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 4409fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (shard_index < 0 || shard_index >= total_shards) { 4410fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Message msg = Message() 4411fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << "Invalid environment variables: we require 0 <= " 4412fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << kTestShardIndex << " < " << kTestTotalShards 4413fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << ", but you have " << kTestShardIndex << "=" << shard_index 4414fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt << ", " << kTestTotalShards << "=" << total_shards << ".\n"; 4415fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 4416fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4417fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 4418fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4419fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4420fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return total_shards > 1; 4421fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4422fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4423fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses the environment variable var as an Int32. If it is unset, 4424fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// returns default_val. If it is not an Int32, prints an error 4425fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// and aborts. 4426fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtInt32 Int32FromEnvOrDie(const char* var, Int32 default_val) { 4427fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* str_val = posix::GetEnv(var); 4428fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (str_val == NULL) { 4429fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return default_val; 4430fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4431fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4432fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Int32 result; 4433fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!ParseInt32(Message() << "The value of environment variable " << var, 4434fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str_val, &result)) { 4435fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt exit(EXIT_FAILURE); 4436fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4437fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return result; 4438fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4439fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4440fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Given the total number of shards, the shard index, and the test id, 4441fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// returns true iff the test should be run on this shard. The test id is 4442fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// some arbitrary but unique non-negative integer assigned to each test 4443fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// method. Assumes that 0 <= shard_index < total_shards. 4444fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { 4445fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (test_id % total_shards) == shard_index; 4446fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4447fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4448fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Compares the name of each test with the user-specified filter to 4449fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// decide whether the test should be run, then records the result in 4450fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// each TestCase and TestInfo object. 4451fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// If shard_tests == true, further filters tests based on sharding 4452fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// variables in the environment - see 4453fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. 4454fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the number of tests that should run. 4455fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtint UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { 4456fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? 4457fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Int32FromEnvOrDie(kTestTotalShards, -1) : -1; 4458fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? 4459fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt Int32FromEnvOrDie(kTestShardIndex, -1) : -1; 4460fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4461fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // num_runnable_tests are the number of tests that will 4462fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // run across all shards (i.e., match filter and are not disabled). 4463fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // num_selected_tests are the number of tests to be run on 4464fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // this shard. 4465fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int num_runnable_tests = 0; 4466fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt int num_selected_tests = 0; 4467fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < test_cases_.size(); i++) { 4468fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestCase* const test_case = test_cases_[i]; 446936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string &test_case_name = test_case->name(); 4470fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_case->set_should_run(false); 4471fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4472fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t j = 0; j < test_case->test_info_list().size(); j++) { 4473fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt TestInfo* const test_info = test_case->test_info_list()[j]; 447436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string test_name(test_info->name()); 4475fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // A test is disabled if test case name or test name matches 4476fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // kDisableTestFilter. 4477fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool is_disabled = 4478fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestOptions::MatchesFilter(test_case_name, 4479fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt kDisableTestFilter) || 4480fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestOptions::MatchesFilter(test_name, 4481fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt kDisableTestFilter); 4482fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_info->is_disabled_ = is_disabled; 4483fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4484fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool matches_filter = 4485fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::UnitTestOptions::FilterMatchesTest(test_case_name, 4486fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_name); 4487fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_info->matches_filter_ = matches_filter; 4488fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4489fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool is_runnable = 4490fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && 4491fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt matches_filter; 4492fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4493fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const bool is_selected = is_runnable && 4494fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (shard_tests == IGNORE_SHARDING_PROTOCOL || 4495fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ShouldRunTestOnShard(total_shards, shard_index, 4496fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_runnable_tests)); 4497fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4498fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_runnable_tests += is_runnable; 4499fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt num_selected_tests += is_selected; 4500fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4501fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_info->should_run_ = is_selected; 4502fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_case->set_should_run(test_case->should_run() || is_selected); 4503fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4504fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4505fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return num_selected_tests; 4506fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4507fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 450836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Prints the given C-string on a single line by replacing all '\n' 450936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// characters with string "\\n". If the output takes more than 451036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// max_length characters, only prints the first max_length characters 451136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// and "...". 451236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestatic void PrintOnOneLine(const char* str, int max_length) { 451336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (str != NULL) { 451436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee for (int i = 0; *str != '\0'; ++str) { 451536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (i >= max_length) { 451636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("..."); 451736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee break; 451836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 451936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (*str == '\n') { 452036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("\\n"); 452136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee i += 2; 452236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } else { 452336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("%c", *str); 452436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ++i; 452536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 452636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 452736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 452836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee} 452936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 4530fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Prints the names of the tests matching the user-specified filter flag. 4531fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::ListTestsMatchingFilter() { 453236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // Print at most this many characters for each type/value parameter. 453336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const int kMaxParamLength = 250; 453436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee 4535fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < test_cases_.size(); i++) { 4536fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestCase* const test_case = test_cases_[i]; 4537fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool printed_test_case_name = false; 4538fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4539fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t j = 0; j < test_case->test_info_list().size(); j++) { 4540fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const TestInfo* const test_info = 4541fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_case->test_info_list()[j]; 4542fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (test_info->matches_filter_) { 4543fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (!printed_test_case_name) { 4544fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt printed_test_case_name = true; 454536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("%s.", test_case->name()); 454636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (test_case->type_param() != NULL) { 454736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf(" # %s = ", kTypeParamLabel); 454836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // We print the type parameter on a single line to make 454936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // the output easy to parse by a program. 455036fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintOnOneLine(test_case->type_param(), kMaxParamLength); 455136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 455236fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("\n"); 455336fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee } 455436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf(" %s", test_info->name()); 455536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee if (test_info->value_param() != NULL) { 455636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf(" # %s = ", kValueParamLabel); 455736fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // We print the value parameter on a single line to make the 455836fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee // output easy to parse by a program. 455936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee PrintOnOneLine(test_info->value_param(), kMaxParamLength); 4560fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 456136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee printf("\n"); 4562fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4563fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4564fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4565fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt fflush(stdout); 4566fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4567fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4568fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Sets the OS stack trace getter. 4569fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4570fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Does nothing if the input and the current OS stack trace getter are 4571fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the same; otherwise, deletes the old getter and makes the input the 4572fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// current getter. 4573fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::set_os_stack_trace_getter( 4574fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt OsStackTraceGetterInterface* getter) { 4575fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (os_stack_trace_getter_ != getter) { 4576fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt delete os_stack_trace_getter_; 4577fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt os_stack_trace_getter_ = getter; 4578fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4579fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4580fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4581fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the current OS stack trace getter if it is not NULL; 4582fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// otherwise, creates an OsStackTraceGetter, makes it the current 4583fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// getter, and returns it. 4584fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtOsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { 4585fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (os_stack_trace_getter_ == NULL) { 4586fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt os_stack_trace_getter_ = new OsStackTraceGetter; 4587fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4588fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4589fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return os_stack_trace_getter_; 4590fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4591fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4592fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the TestResult for the test that's currently running, or 4593fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the TestResult for the ad hoc test if no test is running. 4594fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric AnholtTestResult* UnitTestImpl::current_test_result() { 4595fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return current_test_info_ ? 4596fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt &(current_test_info_->result_) : &ad_hoc_test_result_; 4597fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4598fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4599fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Shuffles all test cases, and the tests within each test case, 4600fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// making sure that death tests are still run first. 4601fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::ShuffleTests() { 4602fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Shuffles the death test cases. 4603fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); 4604fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4605fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Shuffles the non-death test cases. 4606fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ShuffleRange(random(), last_death_test_case_ + 1, 4607fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt static_cast<int>(test_cases_.size()), &test_case_indices_); 4608fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4609fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Shuffles the tests inside each test case. 4610fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < test_cases_.size(); i++) { 4611fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_cases_[i]->ShuffleTests(random()); 4612fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4613fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4614fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4615fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Restores the test cases and tests to their order before the first shuffle. 4616fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid UnitTestImpl::UnshuffleTests() { 4617fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (size_t i = 0; i < test_cases_.size(); i++) { 4618fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Unshuffles the tests in each test case. 4619fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_cases_[i]->UnshuffleTests(); 4620fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Resets the index of each test case. 4621fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt test_case_indices_[i] = static_cast<int>(i); 4622fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4623fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4624fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 462536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee// Returns the current OS stack trace as an std::string. 4626fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4627fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The maximum number of stack frames to be included is specified by 4628fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the gtest_stack_trace_depth flag. The skip_count parameter 4629fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// specifies the number of top frames to be skipped, which doesn't 4630fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// count against the number of frames to be included. 4631fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4632fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// For example, if Foo() calls Bar(), which in turn calls 4633fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in 4634fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. 463536fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leestd::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, 463636fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee int skip_count) { 4637fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We pass skip_count + 1 to skip this wrapper function in addition 4638fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // to what the user really wants to skip. 4639fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); 4640fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4641fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4642fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to 4643fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// suppress unreachable code warnings. 4644fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtnamespace { 4645fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtclass ClassUniqueToAlwaysTrue {}; 4646fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4647fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4648fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool IsTrue(bool condition) { return condition; } 4649fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4650fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool AlwaysTrue() { 4651fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_EXCEPTIONS 4652fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // This condition is always false so AlwaysTrue() never actually throws, 4653fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // but it makes the compiler think that it may throw. 4654fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (IsTrue(false)) 4655fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt throw ClassUniqueToAlwaysTrue(); 4656fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_EXCEPTIONS 4657fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 4658fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4659fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4660fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// If *pstr starts with the given prefix, modifies *pstr to be right 4661fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// past the prefix and returns true; otherwise leaves *pstr unchanged 4662fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// and returns false. None of pstr, *pstr, and prefix can be NULL. 4663fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool SkipPrefix(const char* prefix, const char** pstr) { 4664fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const size_t prefix_len = strlen(prefix); 4665fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (strncmp(*pstr, prefix, prefix_len) == 0) { 4666fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *pstr += prefix_len; 4667fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 4668fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4669fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return false; 4670fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4671fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4672fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses a string as a command line flag. The string should have 4673fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// the format "--flag=value". When def_optional is true, the "=value" 4674fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// part can be omitted. 4675fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4676fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Returns the value of the flag, or NULL if the parsing failed. 4677fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtconst char* ParseFlagValue(const char* str, 4678fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* flag, 4679fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt bool def_optional) { 4680fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // str and flag must not be NULL. 4681fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (str == NULL || flag == NULL) return NULL; 4682fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4683fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. 468436fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; 4685fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const size_t flag_len = flag_str.length(); 4686fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; 4687fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4688fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Skips the flag name. 4689fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* flag_end = str + flag_len; 4690fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4691fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // When def_optional is true, it's OK to not have a "=value" part. 4692fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (def_optional && (flag_end[0] == '\0')) { 4693fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return flag_end; 4694fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4695fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4696fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // If def_optional is true and there are more characters after the 4697fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // flag name, or if def_optional is false, there must be a '=' after 4698fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // the flag name. 4699fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (flag_end[0] != '=') return NULL; 4700fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4701fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Returns the string after "=". 4702fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return flag_end + 1; 4703fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4704fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4705fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses a string for a bool flag, in the form of either 4706fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// "--flag=value" or "--flag". 4707fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4708fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// In the former case, the value is taken as true as long as it does 4709fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// not start with '0', 'f', or 'F'. 4710fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4711fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// In the latter case, the value is taken as true. 4712fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4713fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// On success, stores the value of the flag in *value, and returns 4714fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// true. On failure, returns false without changing *value. 4715fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool ParseBoolFlag(const char* str, const char* flag, bool* value) { 4716fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the value of the flag as a string. 4717fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const value_str = ParseFlagValue(str, flag, true); 4718fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4719fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Aborts if the parsing failed. 4720fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (value_str == NULL) return false; 4721fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4722fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Converts the string value to a bool. 4723fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); 4724fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 4725fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4726fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4727fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses a string for an Int32 flag, in the form of 4728fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// "--flag=value". 4729fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4730fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// On success, stores the value of the flag in *value, and returns 4731fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// true. On failure, returns false without changing *value. 4732fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtbool ParseInt32Flag(const char* str, const char* flag, Int32* value) { 4733fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the value of the flag as a string. 4734fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const value_str = ParseFlagValue(str, flag, false); 4735fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4736fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Aborts if the parsing failed. 4737fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (value_str == NULL) return false; 4738fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4739fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Sets *value to the value of the flag. 4740fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return ParseInt32(Message() << "The value of flag --" << flag, 4741fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt value_str, value); 4742fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4743fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4744fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses a string for a string flag, in the form of 4745fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// "--flag=value". 4746fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4747fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// On success, stores the value of the flag in *value, and returns 4748fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// true. On failure, returns false without changing *value. 474936fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Leebool ParseStringFlag(const char* str, const char* flag, std::string* value) { 4750fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Gets the value of the flag as a string. 4751fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const value_str = ParseFlagValue(str, flag, false); 4752fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4753fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Aborts if the parsing failed. 4754fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (value_str == NULL) return false; 4755fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4756fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Sets *value to the value of the flag. 4757fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt *value = value_str; 4758fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return true; 4759fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4760fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4761fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Determines whether a string has a prefix that Google Test uses for its 4762fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. 4763fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// If Google Test detects that a command line flag has its prefix but is not 4764fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// recognized, it will print its help message. Flags starting with 4765fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test 4766fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// internal flags and do not trigger the help message. 4767fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic bool HasGoogleTestFlagPrefix(const char* str) { 4768fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return (SkipPrefix("--", &str) || 4769fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SkipPrefix("-", &str) || 4770fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SkipPrefix("/", &str)) && 4771fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && 4772fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || 4773fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); 4774fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4775fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4776fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Prints a string containing code-encoded text. The following escape 4777fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// sequences can be used in the string to control the text color: 4778fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4779fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// @@ prints a single '@' character. 4780fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// @R changes the color to red. 4781fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// @G changes the color to green. 4782fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// @Y changes the color to yellow. 4783fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// @D changes to the default terminal text color. 4784fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4785fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// TODO(wan@google.com): Write tests for this once we add stdout 4786fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// capturing to Google Test. 4787fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic void PrintColorEncoded(const char* str) { 4788fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTestColor color = COLOR_DEFAULT; // The current color. 4789fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4790fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Conceptually, we split the string into segments divided by escape 4791fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // sequences. Then we print one segment at a time. At the end of 4792fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // each iteration, the str pointer advances to the beginning of the 4793fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // next segment. 4794fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (;;) { 4795fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* p = strchr(str, '@'); 4796fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (p == NULL) { 4797fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(color, "%s", str); 4798fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt return; 4799fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4800fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 480136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee ColoredPrintf(color, "%s", std::string(str, p).c_str()); 4802fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4803fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char ch = p[1]; 4804fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt str = p + 2; 4805fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (ch == '@') { 4806fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ColoredPrintf(color, "@"); 4807fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (ch == 'D') { 4808fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt color = COLOR_DEFAULT; 4809fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (ch == 'R') { 4810fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt color = COLOR_RED; 4811fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (ch == 'G') { 4812fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt color = COLOR_GREEN; 4813fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (ch == 'Y') { 4814fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt color = COLOR_YELLOW; 4815fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else { 4816fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt --str; 4817fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4818fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4819fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4820fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4821fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtstatic const char kColorEncodedHelpMessage[] = 4822fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"This program contains tests written using " GTEST_NAME_ ". You can use the\n" 4823fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"following command line flags to control its behavior:\n" 4824fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"\n" 4825fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"Test Selection:\n" 4826fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" 4827fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" List the names of all tests instead of running them. The name of\n" 4828fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" TEST(Foo, Bar) is \"Foo.Bar\".\n" 4829fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" 4830fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "[@G-@YNEGATIVE_PATTERNS]@D\n" 4831fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Run only the tests whose name matches one of the positive patterns but\n" 4832fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" none of the negative patterns. '?' matches any single character; '*'\n" 4833fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" matches any substring; ':' separates two patterns.\n" 4834fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" 4835fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Run all disabled tests too.\n" 4836fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"\n" 4837fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"Test Execution:\n" 4838fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" 4839fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Run the tests repeatedly; use a negative count to repeat forever.\n" 4840fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" 4841fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Randomize tests' orders on every iteration.\n" 4842fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" 4843fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Random number seed to use for shuffling test orders (between 1 and\n" 4844fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" 99999, or 0 to use a seed based on the current time).\n" 4845fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"\n" 4846fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"Test Output:\n" 4847fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" 4848fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Enable/disable colored output. The default is @Gauto@D.\n" 4849fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" 4850fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Don't print the elapsed time of each test.\n" 4851fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" 4852fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" 4853fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Generate an XML report in the given directory or with the given file\n" 4854fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" 4855fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_CAN_STREAM_RESULTS_ 4856fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" 4857fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Stream test results to the given server.\n" 4858fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_CAN_STREAM_RESULTS_ 4859fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"\n" 4860fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"Assertion Behavior:\n" 4861fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 4862fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" 4863fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Set the default death test style.\n" 4864fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 4865fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" 4866fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Turn assertion failures into debugger break-points.\n" 4867fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" 4868fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Turn assertion failures into C++ exceptions.\n" 4869fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" 4870fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" Do not report exceptions as test failures. Instead, allow them\n" 4871fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt" to crash the program or throw a pop-up (on Windows).\n" 4872fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"\n" 4873fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " 4874fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "the corresponding\n" 4875fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"environment variable of a flag (all letters in upper-case). For example, to\n" 4876fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ 4877fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt "color=no@D or set\n" 4878fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" 4879fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"\n" 4880fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"For more information, please read the " GTEST_NAME_ " documentation at\n" 4881fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" 4882fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"(not one in your own code or tests), please report it to\n" 4883fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt"@G<" GTEST_DEV_EMAIL_ ">@D.\n"; 4884fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4885fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses the command line for Google Test flags, without initializing 4886fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// other parts of Google Test. The type parameter CharType can be 4887fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// instantiated to either char or wchar_t. 4888fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <typename CharType> 4889fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { 4890fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 1; i < *argc; i++) { 489136fb36aa36d8933fef04c1bdaed3ccc9b5108908Vinson Lee const std::string arg_string = StreamableToString(argv[i]); 4892fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt const char* const arg = arg_string.c_str(); 4893fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4894fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt using internal::ParseBoolFlag; 4895fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt using internal::ParseInt32Flag; 4896fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt using internal::ParseStringFlag; 4897fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4898fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Do we see a Google Test flag? 4899fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, 4900fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(also_run_disabled_tests)) || 4901fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kBreakOnFailureFlag, 4902fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(break_on_failure)) || 4903fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kCatchExceptionsFlag, 4904fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(catch_exceptions)) || 4905fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || 4906fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseStringFlag(arg, kDeathTestStyleFlag, 4907fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(death_test_style)) || 4908fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kDeathTestUseFork, 4909fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(death_test_use_fork)) || 4910fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || 4911fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseStringFlag(arg, kInternalRunDeathTestFlag, 4912fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(internal_run_death_test)) || 4913fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || 4914fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || 4915fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || 4916fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || 4917fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || 4918fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || 4919fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseInt32Flag(arg, kStackTraceDepthFlag, 4920fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(stack_trace_depth)) || 4921fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseStringFlag(arg, kStreamResultToFlag, 4922fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(stream_result_to)) || 4923fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseBoolFlag(arg, kThrowOnFailureFlag, 4924fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt >EST_FLAG(throw_on_failure)) 4925fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ) { 4926fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Yes. Shift the remainder of the argv list left by one. Note 4927fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // that argv has (*argc + 1) elements, the last one always being 4928fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // NULL. The following loop moves the trailing NULL element as 4929fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // well. 4930fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int j = i; j != *argc; j++) { 4931fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt argv[j] = argv[j + 1]; 4932fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4933fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4934fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Decrements the argument count. 4935fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt (*argc)--; 4936fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4937fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We also need to decrement the iterator as we just removed 4938fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // an element. 4939fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt i--; 4940fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } else if (arg_string == "--help" || arg_string == "-h" || 4941fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt arg_string == "-?" || arg_string == "/?" || 4942fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt HasGoogleTestFlagPrefix(arg)) { 4943fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Both help flag and unrecognized Google Test flags (excluding 4944fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // internal ones) trigger help display. 4945fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt g_help_flag = true; 4946fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4947fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4948fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4949fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (g_help_flag) { 4950fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We print the help here instead of in RUN_ALL_TESTS(), as the 4951fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // latter may not be called at all if the user is using Google 4952fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // Test with another testing framework. 4953fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt PrintColorEncoded(kColorEncodedHelpMessage); 4954fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4955fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4956fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4957fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Parses the command line for Google Test flags, without initializing 4958fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// other parts of Google Test. 4959fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ParseGoogleTestFlagsOnly(int* argc, char** argv) { 4960fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseGoogleTestFlagsOnlyImpl(argc, argv); 4961fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4962fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { 4963fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseGoogleTestFlagsOnlyImpl(argc, argv); 4964fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4965fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4966fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The internal implementation of InitGoogleTest(). 4967fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 4968fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// The type parameter CharType can be instantiated to either char or 4969fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// wchar_t. 4970fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholttemplate <typename CharType> 4971fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid InitGoogleTestImpl(int* argc, CharType** argv) { 4972fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt g_init_gtest_count++; 4973fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4974fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt // We don't want to run the initialization code twice. 4975fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (g_init_gtest_count != 1) return; 4976fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4977fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt if (*argc <= 0) return; 4978fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4979fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::g_executable_path = internal::StreamableToString(argv[0]); 4980fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4981fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#if GTEST_HAS_DEATH_TEST 4982fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4983fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt g_argvs.clear(); 4984fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt for (int i = 0; i != *argc; i++) { 4985fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt g_argvs.push_back(StreamableToString(argv[i])); 4986fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt } 4987fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4988fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt#endif // GTEST_HAS_DEATH_TEST 4989fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4990fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt ParseGoogleTestFlagsOnly(argc, argv); 4991fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt GetUnitTestImpl()->PostFlagParsingInit(); 4992fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 4993fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4994fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace internal 4995fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 4996fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Initializes Google Test. This must be called before calling 4997fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// RUN_ALL_TESTS(). In particular, it parses a command line for the 4998fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// flags that Google Test recognizes. Whenever a Google Test flag is 4999fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// seen, it is removed from argv, and *argc is decremented. 5000fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 5001fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// No value is returned. Instead, the Google Test flag variables are 5002fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// updated. 5003fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// 5004fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// Calling the function for the second time has no user-visible effect. 5005fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid InitGoogleTest(int* argc, char** argv) { 5006fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::InitGoogleTestImpl(argc, argv); 5007fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 5008fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 5009fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// This overloaded version can be used in Windows programs compiled in 5010fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt// UNICODE mode. 5011fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholtvoid InitGoogleTest(int* argc, wchar_t** argv) { 5012fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt internal::InitGoogleTestImpl(argc, argv); 5013fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} 5014fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt 5015fe358c0ffa4acb7ecab10fda68ba9740497d2e7fEric Anholt} // namespace testing 5016