113481Sgiacomo.travaglini@arm.com// Copyright 2005, Google Inc. 213481Sgiacomo.travaglini@arm.com// All rights reserved. 313481Sgiacomo.travaglini@arm.com// 413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without 513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are 613481Sgiacomo.travaglini@arm.com// met: 713481Sgiacomo.travaglini@arm.com// 813481Sgiacomo.travaglini@arm.com// * Redistributions of source code must retain the above copyright 913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer. 1013481Sgiacomo.travaglini@arm.com// * Redistributions in binary form must reproduce the above 1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer 1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the 1313481Sgiacomo.travaglini@arm.com// distribution. 1413481Sgiacomo.travaglini@arm.com// * Neither the name of Google Inc. nor the names of its 1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from 1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission. 1713481Sgiacomo.travaglini@arm.com// 1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2913481Sgiacomo.travaglini@arm.com// 3013481Sgiacomo.travaglini@arm.com// Author: wan@google.com (Zhanyong Wan) 3113481Sgiacomo.travaglini@arm.com// 3213481Sgiacomo.travaglini@arm.com// The Google C++ Testing Framework (Google Test) 3313481Sgiacomo.travaglini@arm.com 3413481Sgiacomo.travaglini@arm.com#include "gtest/gtest.h" 3513481Sgiacomo.travaglini@arm.com#include "gtest/internal/custom/gtest.h" 3613481Sgiacomo.travaglini@arm.com#include "gtest/gtest-spi.h" 3713481Sgiacomo.travaglini@arm.com 3813481Sgiacomo.travaglini@arm.com#include <ctype.h> 3913481Sgiacomo.travaglini@arm.com#include <math.h> 4013481Sgiacomo.travaglini@arm.com#include <stdarg.h> 4113481Sgiacomo.travaglini@arm.com#include <stdio.h> 4213481Sgiacomo.travaglini@arm.com#include <stdlib.h> 4313481Sgiacomo.travaglini@arm.com#include <time.h> 4413481Sgiacomo.travaglini@arm.com#include <wchar.h> 4513481Sgiacomo.travaglini@arm.com#include <wctype.h> 4613481Sgiacomo.travaglini@arm.com 4713481Sgiacomo.travaglini@arm.com#include <algorithm> 4813481Sgiacomo.travaglini@arm.com#include <iomanip> 4913481Sgiacomo.travaglini@arm.com#include <limits> 5013481Sgiacomo.travaglini@arm.com#include <list> 5113481Sgiacomo.travaglini@arm.com#include <map> 5213481Sgiacomo.travaglini@arm.com#include <ostream> // NOLINT 5313481Sgiacomo.travaglini@arm.com#include <sstream> 5413481Sgiacomo.travaglini@arm.com#include <vector> 5513481Sgiacomo.travaglini@arm.com 5613481Sgiacomo.travaglini@arm.com#if GTEST_OS_LINUX 5713481Sgiacomo.travaglini@arm.com 5813481Sgiacomo.travaglini@arm.com// TODO(kenton@google.com): Use autoconf to detect availability of 5913481Sgiacomo.travaglini@arm.com// gettimeofday(). 6013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GETTIMEOFDAY_ 1 6113481Sgiacomo.travaglini@arm.com 6213481Sgiacomo.travaglini@arm.com# include <fcntl.h> // NOLINT 6313481Sgiacomo.travaglini@arm.com# include <limits.h> // NOLINT 6413481Sgiacomo.travaglini@arm.com# include <sched.h> // NOLINT 6513481Sgiacomo.travaglini@arm.com// Declares vsnprintf(). This header is not available on Windows. 6613481Sgiacomo.travaglini@arm.com# include <strings.h> // NOLINT 6713481Sgiacomo.travaglini@arm.com# include <sys/mman.h> // NOLINT 6813481Sgiacomo.travaglini@arm.com# include <sys/time.h> // NOLINT 6913481Sgiacomo.travaglini@arm.com# include <unistd.h> // NOLINT 7013481Sgiacomo.travaglini@arm.com# include <string> 7113481Sgiacomo.travaglini@arm.com 7213481Sgiacomo.travaglini@arm.com#elif GTEST_OS_SYMBIAN 7313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GETTIMEOFDAY_ 1 7413481Sgiacomo.travaglini@arm.com# include <sys/time.h> // NOLINT 7513481Sgiacomo.travaglini@arm.com 7613481Sgiacomo.travaglini@arm.com#elif GTEST_OS_ZOS 7713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GETTIMEOFDAY_ 1 7813481Sgiacomo.travaglini@arm.com# include <sys/time.h> // NOLINT 7913481Sgiacomo.travaglini@arm.com 8013481Sgiacomo.travaglini@arm.com// On z/OS we additionally need strings.h for strcasecmp. 8113481Sgiacomo.travaglini@arm.com# include <strings.h> // NOLINT 8213481Sgiacomo.travaglini@arm.com 8313481Sgiacomo.travaglini@arm.com#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. 8413481Sgiacomo.travaglini@arm.com 8513481Sgiacomo.travaglini@arm.com# include <windows.h> // NOLINT 8613481Sgiacomo.travaglini@arm.com# undef min 8713481Sgiacomo.travaglini@arm.com 8813481Sgiacomo.travaglini@arm.com#elif GTEST_OS_WINDOWS // We are on Windows proper. 8913481Sgiacomo.travaglini@arm.com 9013481Sgiacomo.travaglini@arm.com# include <io.h> // NOLINT 9113481Sgiacomo.travaglini@arm.com# include <sys/timeb.h> // NOLINT 9213481Sgiacomo.travaglini@arm.com# include <sys/types.h> // NOLINT 9313481Sgiacomo.travaglini@arm.com# include <sys/stat.h> // NOLINT 9413481Sgiacomo.travaglini@arm.com 9513481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MINGW 9613481Sgiacomo.travaglini@arm.com// MinGW has gettimeofday() but not _ftime64(). 9713481Sgiacomo.travaglini@arm.com// TODO(kenton@google.com): Use autoconf to detect availability of 9813481Sgiacomo.travaglini@arm.com// gettimeofday(). 9913481Sgiacomo.travaglini@arm.com// TODO(kenton@google.com): There are other ways to get the time on 10013481Sgiacomo.travaglini@arm.com// Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW 10113481Sgiacomo.travaglini@arm.com// supports these. consider using them instead. 10213481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GETTIMEOFDAY_ 1 10313481Sgiacomo.travaglini@arm.com# include <sys/time.h> // NOLINT 10413481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS_MINGW 10513481Sgiacomo.travaglini@arm.com 10613481Sgiacomo.travaglini@arm.com// cpplint thinks that the header is already included, so we want to 10713481Sgiacomo.travaglini@arm.com// silence it. 10813481Sgiacomo.travaglini@arm.com# include <windows.h> // NOLINT 10913481Sgiacomo.travaglini@arm.com# undef min 11013481Sgiacomo.travaglini@arm.com 11113481Sgiacomo.travaglini@arm.com#else 11213481Sgiacomo.travaglini@arm.com 11313481Sgiacomo.travaglini@arm.com// Assume other platforms have gettimeofday(). 11413481Sgiacomo.travaglini@arm.com// TODO(kenton@google.com): Use autoconf to detect availability of 11513481Sgiacomo.travaglini@arm.com// gettimeofday(). 11613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GETTIMEOFDAY_ 1 11713481Sgiacomo.travaglini@arm.com 11813481Sgiacomo.travaglini@arm.com// cpplint thinks that the header is already included, so we want to 11913481Sgiacomo.travaglini@arm.com// silence it. 12013481Sgiacomo.travaglini@arm.com# include <sys/time.h> // NOLINT 12113481Sgiacomo.travaglini@arm.com# include <unistd.h> // NOLINT 12213481Sgiacomo.travaglini@arm.com 12313481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_LINUX 12413481Sgiacomo.travaglini@arm.com 12513481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 12613481Sgiacomo.travaglini@arm.com# include <stdexcept> 12713481Sgiacomo.travaglini@arm.com#endif 12813481Sgiacomo.travaglini@arm.com 12913481Sgiacomo.travaglini@arm.com#if GTEST_CAN_STREAM_RESULTS_ 13013481Sgiacomo.travaglini@arm.com# include <arpa/inet.h> // NOLINT 13113481Sgiacomo.travaglini@arm.com# include <netdb.h> // NOLINT 13213481Sgiacomo.travaglini@arm.com# include <sys/socket.h> // NOLINT 13313481Sgiacomo.travaglini@arm.com# include <sys/types.h> // NOLINT 13413481Sgiacomo.travaglini@arm.com#endif 13513481Sgiacomo.travaglini@arm.com 13613481Sgiacomo.travaglini@arm.com// Indicates that this translation unit is part of Google Test's 13713481Sgiacomo.travaglini@arm.com// implementation. It must come before gtest-internal-inl.h is 13813481Sgiacomo.travaglini@arm.com// included, or there will be a compiler error. This trick is to 13913481Sgiacomo.travaglini@arm.com// prevent a user from accidentally including gtest-internal-inl.h in 14013481Sgiacomo.travaglini@arm.com// his code. 14113481Sgiacomo.travaglini@arm.com#define GTEST_IMPLEMENTATION_ 1 14213481Sgiacomo.travaglini@arm.com#include "src/gtest-internal-inl.h" 14313481Sgiacomo.travaglini@arm.com#undef GTEST_IMPLEMENTATION_ 14413481Sgiacomo.travaglini@arm.com 14513481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 14613481Sgiacomo.travaglini@arm.com# define vsnprintf _vsnprintf 14713481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 14813481Sgiacomo.travaglini@arm.com 14913481Sgiacomo.travaglini@arm.comnamespace testing { 15013481Sgiacomo.travaglini@arm.com 15113481Sgiacomo.travaglini@arm.comusing internal::CountIf; 15213481Sgiacomo.travaglini@arm.comusing internal::ForEach; 15313481Sgiacomo.travaglini@arm.comusing internal::GetElementOr; 15413481Sgiacomo.travaglini@arm.comusing internal::Shuffle; 15513481Sgiacomo.travaglini@arm.com 15613481Sgiacomo.travaglini@arm.com// Constants. 15713481Sgiacomo.travaglini@arm.com 15813481Sgiacomo.travaglini@arm.com// A test whose test case name or test name matches this filter is 15913481Sgiacomo.travaglini@arm.com// disabled and not run. 16013481Sgiacomo.travaglini@arm.comstatic const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; 16113481Sgiacomo.travaglini@arm.com 16213481Sgiacomo.travaglini@arm.com// A test case whose name matches this filter is considered a death 16313481Sgiacomo.travaglini@arm.com// test case and will be run before test cases whose name doesn't 16413481Sgiacomo.travaglini@arm.com// match this filter. 16513481Sgiacomo.travaglini@arm.comstatic const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"; 16613481Sgiacomo.travaglini@arm.com 16713481Sgiacomo.travaglini@arm.com// A test filter that matches everything. 16813481Sgiacomo.travaglini@arm.comstatic const char kUniversalFilter[] = "*"; 16913481Sgiacomo.travaglini@arm.com 17013481Sgiacomo.travaglini@arm.com// The default output file for XML output. 17113481Sgiacomo.travaglini@arm.comstatic const char kDefaultOutputFile[] = "test_detail.xml"; 17213481Sgiacomo.travaglini@arm.com 17313481Sgiacomo.travaglini@arm.com// The environment variable name for the test shard index. 17413481Sgiacomo.travaglini@arm.comstatic const char kTestShardIndex[] = "GTEST_SHARD_INDEX"; 17513481Sgiacomo.travaglini@arm.com// The environment variable name for the total number of test shards. 17613481Sgiacomo.travaglini@arm.comstatic const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS"; 17713481Sgiacomo.travaglini@arm.com// The environment variable name for the test shard status file. 17813481Sgiacomo.travaglini@arm.comstatic const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"; 17913481Sgiacomo.travaglini@arm.com 18013481Sgiacomo.travaglini@arm.comnamespace internal { 18113481Sgiacomo.travaglini@arm.com 18213481Sgiacomo.travaglini@arm.com// The text used in failure messages to indicate the start of the 18313481Sgiacomo.travaglini@arm.com// stack trace. 18413481Sgiacomo.travaglini@arm.comconst char kStackTraceMarker[] = "\nStack trace:\n"; 18513481Sgiacomo.travaglini@arm.com 18613481Sgiacomo.travaglini@arm.com// g_help_flag is true iff the --help flag or an equivalent form is 18713481Sgiacomo.travaglini@arm.com// specified on the command line. 18813481Sgiacomo.travaglini@arm.combool g_help_flag = false; 18913481Sgiacomo.travaglini@arm.com 19013481Sgiacomo.travaglini@arm.com} // namespace internal 19113481Sgiacomo.travaglini@arm.com 19213481Sgiacomo.travaglini@arm.comstatic const char* GetDefaultFilter() { 19313481Sgiacomo.travaglini@arm.com#ifdef GTEST_TEST_FILTER_ENV_VAR_ 19413481Sgiacomo.travaglini@arm.com const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_); 19513481Sgiacomo.travaglini@arm.com if (testbridge_test_only != NULL) { 19613481Sgiacomo.travaglini@arm.com return testbridge_test_only; 19713481Sgiacomo.travaglini@arm.com } 19813481Sgiacomo.travaglini@arm.com#endif // GTEST_TEST_FILTER_ENV_VAR_ 19913481Sgiacomo.travaglini@arm.com return kUniversalFilter; 20013481Sgiacomo.travaglini@arm.com} 20113481Sgiacomo.travaglini@arm.com 20213481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 20313481Sgiacomo.travaglini@arm.com also_run_disabled_tests, 20413481Sgiacomo.travaglini@arm.com internal::BoolFromGTestEnv("also_run_disabled_tests", false), 20513481Sgiacomo.travaglini@arm.com "Run disabled tests too, in addition to the tests normally being run."); 20613481Sgiacomo.travaglini@arm.com 20713481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 20813481Sgiacomo.travaglini@arm.com break_on_failure, 20913481Sgiacomo.travaglini@arm.com internal::BoolFromGTestEnv("break_on_failure", false), 21013481Sgiacomo.travaglini@arm.com "True iff a failed assertion should be a debugger break-point."); 21113481Sgiacomo.travaglini@arm.com 21213481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 21313481Sgiacomo.travaglini@arm.com catch_exceptions, 21413481Sgiacomo.travaglini@arm.com internal::BoolFromGTestEnv("catch_exceptions", true), 21513481Sgiacomo.travaglini@arm.com "True iff " GTEST_NAME_ 21613481Sgiacomo.travaglini@arm.com " should catch exceptions and treat them as test failures."); 21713481Sgiacomo.travaglini@arm.com 21813481Sgiacomo.travaglini@arm.comGTEST_DEFINE_string_( 21913481Sgiacomo.travaglini@arm.com color, 22013481Sgiacomo.travaglini@arm.com internal::StringFromGTestEnv("color", "auto"), 22113481Sgiacomo.travaglini@arm.com "Whether to use colors in the output. Valid values: yes, no, " 22213481Sgiacomo.travaglini@arm.com "and auto. 'auto' means to use colors if the output is " 22313481Sgiacomo.travaglini@arm.com "being sent to a terminal and the TERM environment variable " 22413481Sgiacomo.travaglini@arm.com "is set to a terminal type that supports colors."); 22513481Sgiacomo.travaglini@arm.com 22613481Sgiacomo.travaglini@arm.comGTEST_DEFINE_string_( 22713481Sgiacomo.travaglini@arm.com filter, 22813481Sgiacomo.travaglini@arm.com internal::StringFromGTestEnv("filter", GetDefaultFilter()), 22913481Sgiacomo.travaglini@arm.com "A colon-separated list of glob (not regex) patterns " 23013481Sgiacomo.travaglini@arm.com "for filtering the tests to run, optionally followed by a " 23113481Sgiacomo.travaglini@arm.com "'-' and a : separated list of negative patterns (tests to " 23213481Sgiacomo.travaglini@arm.com "exclude). A test is run if it matches one of the positive " 23313481Sgiacomo.travaglini@arm.com "patterns and does not match any of the negative patterns."); 23413481Sgiacomo.travaglini@arm.com 23513481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_(list_tests, false, 23613481Sgiacomo.travaglini@arm.com "List all tests without running them."); 23713481Sgiacomo.travaglini@arm.com 23813481Sgiacomo.travaglini@arm.comGTEST_DEFINE_string_( 23913481Sgiacomo.travaglini@arm.com output, 24013481Sgiacomo.travaglini@arm.com internal::StringFromGTestEnv("output", ""), 24113481Sgiacomo.travaglini@arm.com "A format (currently must be \"xml\"), optionally followed " 24213481Sgiacomo.travaglini@arm.com "by a colon and an output file name or directory. A directory " 24313481Sgiacomo.travaglini@arm.com "is indicated by a trailing pathname separator. " 24413481Sgiacomo.travaglini@arm.com "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " 24513481Sgiacomo.travaglini@arm.com "If a directory is specified, output files will be created " 24613481Sgiacomo.travaglini@arm.com "within that directory, with file-names based on the test " 24713481Sgiacomo.travaglini@arm.com "executable's name and, if necessary, made unique by adding " 24813481Sgiacomo.travaglini@arm.com "digits."); 24913481Sgiacomo.travaglini@arm.com 25013481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 25113481Sgiacomo.travaglini@arm.com print_time, 25213481Sgiacomo.travaglini@arm.com internal::BoolFromGTestEnv("print_time", true), 25313481Sgiacomo.travaglini@arm.com "True iff " GTEST_NAME_ 25413481Sgiacomo.travaglini@arm.com " should display elapsed time in text output."); 25513481Sgiacomo.travaglini@arm.com 25613481Sgiacomo.travaglini@arm.comGTEST_DEFINE_int32_( 25713481Sgiacomo.travaglini@arm.com random_seed, 25813481Sgiacomo.travaglini@arm.com internal::Int32FromGTestEnv("random_seed", 0), 25913481Sgiacomo.travaglini@arm.com "Random number seed to use when shuffling test orders. Must be in range " 26013481Sgiacomo.travaglini@arm.com "[1, 99999], or 0 to use a seed based on the current time."); 26113481Sgiacomo.travaglini@arm.com 26213481Sgiacomo.travaglini@arm.comGTEST_DEFINE_int32_( 26313481Sgiacomo.travaglini@arm.com repeat, 26413481Sgiacomo.travaglini@arm.com internal::Int32FromGTestEnv("repeat", 1), 26513481Sgiacomo.travaglini@arm.com "How many times to repeat each test. Specify a negative number " 26613481Sgiacomo.travaglini@arm.com "for repeating forever. Useful for shaking out flaky tests."); 26713481Sgiacomo.travaglini@arm.com 26813481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 26913481Sgiacomo.travaglini@arm.com show_internal_stack_frames, false, 27013481Sgiacomo.travaglini@arm.com "True iff " GTEST_NAME_ " should include internal stack frames when " 27113481Sgiacomo.travaglini@arm.com "printing test failure stack traces."); 27213481Sgiacomo.travaglini@arm.com 27313481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 27413481Sgiacomo.travaglini@arm.com shuffle, 27513481Sgiacomo.travaglini@arm.com internal::BoolFromGTestEnv("shuffle", false), 27613481Sgiacomo.travaglini@arm.com "True iff " GTEST_NAME_ 27713481Sgiacomo.travaglini@arm.com " should randomize tests' order on every run."); 27813481Sgiacomo.travaglini@arm.com 27913481Sgiacomo.travaglini@arm.comGTEST_DEFINE_int32_( 28013481Sgiacomo.travaglini@arm.com stack_trace_depth, 28113481Sgiacomo.travaglini@arm.com internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), 28213481Sgiacomo.travaglini@arm.com "The maximum number of stack frames to print when an " 28313481Sgiacomo.travaglini@arm.com "assertion fails. The valid range is 0 through 100, inclusive."); 28413481Sgiacomo.travaglini@arm.com 28513481Sgiacomo.travaglini@arm.comGTEST_DEFINE_string_( 28613481Sgiacomo.travaglini@arm.com stream_result_to, 28713481Sgiacomo.travaglini@arm.com internal::StringFromGTestEnv("stream_result_to", ""), 28813481Sgiacomo.travaglini@arm.com "This flag specifies the host name and the port number on which to stream " 28913481Sgiacomo.travaglini@arm.com "test results. Example: \"localhost:555\". The flag is effective only on " 29013481Sgiacomo.travaglini@arm.com "Linux."); 29113481Sgiacomo.travaglini@arm.com 29213481Sgiacomo.travaglini@arm.comGTEST_DEFINE_bool_( 29313481Sgiacomo.travaglini@arm.com throw_on_failure, 29413481Sgiacomo.travaglini@arm.com internal::BoolFromGTestEnv("throw_on_failure", false), 29513481Sgiacomo.travaglini@arm.com "When this flag is specified, a failed assertion will throw an exception " 29613481Sgiacomo.travaglini@arm.com "if exceptions are enabled or exit the program with a non-zero code " 29713481Sgiacomo.travaglini@arm.com "otherwise."); 29813481Sgiacomo.travaglini@arm.com 29913481Sgiacomo.travaglini@arm.com#if GTEST_USE_OWN_FLAGFILE_FLAG_ 30013481Sgiacomo.travaglini@arm.comGTEST_DEFINE_string_( 30113481Sgiacomo.travaglini@arm.com flagfile, 30213481Sgiacomo.travaglini@arm.com internal::StringFromGTestEnv("flagfile", ""), 30313481Sgiacomo.travaglini@arm.com "This flag specifies the flagfile to read command-line flags from."); 30413481Sgiacomo.travaglini@arm.com#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ 30513481Sgiacomo.travaglini@arm.com 30613481Sgiacomo.travaglini@arm.comnamespace internal { 30713481Sgiacomo.travaglini@arm.com 30813481Sgiacomo.travaglini@arm.com// Generates a random number from [0, range), using a Linear 30913481Sgiacomo.travaglini@arm.com// Congruential Generator (LCG). Crashes if 'range' is 0 or greater 31013481Sgiacomo.travaglini@arm.com// than kMaxRange. 31113481Sgiacomo.travaglini@arm.comUInt32 Random::Generate(UInt32 range) { 31213481Sgiacomo.travaglini@arm.com // These constants are the same as are used in glibc's rand(3). 31313481Sgiacomo.travaglini@arm.com state_ = (1103515245U*state_ + 12345U) % kMaxRange; 31413481Sgiacomo.travaglini@arm.com 31513481Sgiacomo.travaglini@arm.com GTEST_CHECK_(range > 0) 31613481Sgiacomo.travaglini@arm.com << "Cannot generate a number in the range [0, 0)."; 31713481Sgiacomo.travaglini@arm.com GTEST_CHECK_(range <= kMaxRange) 31813481Sgiacomo.travaglini@arm.com << "Generation of a number in [0, " << range << ") was requested, " 31913481Sgiacomo.travaglini@arm.com << "but this can only generate numbers in [0, " << kMaxRange << ")."; 32013481Sgiacomo.travaglini@arm.com 32113481Sgiacomo.travaglini@arm.com // Converting via modulus introduces a bit of downward bias, but 32213481Sgiacomo.travaglini@arm.com // it's simple, and a linear congruential generator isn't too good 32313481Sgiacomo.travaglini@arm.com // to begin with. 32413481Sgiacomo.travaglini@arm.com return state_ % range; 32513481Sgiacomo.travaglini@arm.com} 32613481Sgiacomo.travaglini@arm.com 32713481Sgiacomo.travaglini@arm.com// GTestIsInitialized() returns true iff the user has initialized 32813481Sgiacomo.travaglini@arm.com// Google Test. Useful for catching the user mistake of not initializing 32913481Sgiacomo.travaglini@arm.com// Google Test before calling RUN_ALL_TESTS(). 33013481Sgiacomo.travaglini@arm.comstatic bool GTestIsInitialized() { return GetArgvs().size() > 0; } 33113481Sgiacomo.travaglini@arm.com 33213481Sgiacomo.travaglini@arm.com// Iterates over a vector of TestCases, keeping a running sum of the 33313481Sgiacomo.travaglini@arm.com// results of calling a given int-returning method on each. 33413481Sgiacomo.travaglini@arm.com// Returns the sum. 33513481Sgiacomo.travaglini@arm.comstatic int SumOverTestCaseList(const std::vector<TestCase*>& case_list, 33613481Sgiacomo.travaglini@arm.com int (TestCase::*method)() const) { 33713481Sgiacomo.travaglini@arm.com int sum = 0; 33813481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < case_list.size(); i++) { 33913481Sgiacomo.travaglini@arm.com sum += (case_list[i]->*method)(); 34013481Sgiacomo.travaglini@arm.com } 34113481Sgiacomo.travaglini@arm.com return sum; 34213481Sgiacomo.travaglini@arm.com} 34313481Sgiacomo.travaglini@arm.com 34413481Sgiacomo.travaglini@arm.com// Returns true iff the test case passed. 34513481Sgiacomo.travaglini@arm.comstatic bool TestCasePassed(const TestCase* test_case) { 34613481Sgiacomo.travaglini@arm.com return test_case->should_run() && test_case->Passed(); 34713481Sgiacomo.travaglini@arm.com} 34813481Sgiacomo.travaglini@arm.com 34913481Sgiacomo.travaglini@arm.com// Returns true iff the test case failed. 35013481Sgiacomo.travaglini@arm.comstatic bool TestCaseFailed(const TestCase* test_case) { 35113481Sgiacomo.travaglini@arm.com return test_case->should_run() && test_case->Failed(); 35213481Sgiacomo.travaglini@arm.com} 35313481Sgiacomo.travaglini@arm.com 35413481Sgiacomo.travaglini@arm.com// Returns true iff test_case contains at least one test that should 35513481Sgiacomo.travaglini@arm.com// run. 35613481Sgiacomo.travaglini@arm.comstatic bool ShouldRunTestCase(const TestCase* test_case) { 35713481Sgiacomo.travaglini@arm.com return test_case->should_run(); 35813481Sgiacomo.travaglini@arm.com} 35913481Sgiacomo.travaglini@arm.com 36013481Sgiacomo.travaglini@arm.com// AssertHelper constructor. 36113481Sgiacomo.travaglini@arm.comAssertHelper::AssertHelper(TestPartResult::Type type, 36213481Sgiacomo.travaglini@arm.com const char* file, 36313481Sgiacomo.travaglini@arm.com int line, 36413481Sgiacomo.travaglini@arm.com const char* message) 36513481Sgiacomo.travaglini@arm.com : data_(new AssertHelperData(type, file, line, message)) { 36613481Sgiacomo.travaglini@arm.com} 36713481Sgiacomo.travaglini@arm.com 36813481Sgiacomo.travaglini@arm.comAssertHelper::~AssertHelper() { 36913481Sgiacomo.travaglini@arm.com delete data_; 37013481Sgiacomo.travaglini@arm.com} 37113481Sgiacomo.travaglini@arm.com 37213481Sgiacomo.travaglini@arm.com// Message assignment, for assertion streaming support. 37313481Sgiacomo.travaglini@arm.comvoid AssertHelper::operator=(const Message& message) const { 37413481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()-> 37513481Sgiacomo.travaglini@arm.com AddTestPartResult(data_->type, data_->file, data_->line, 37613481Sgiacomo.travaglini@arm.com AppendUserMessage(data_->message, message), 37713481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()->impl() 37813481Sgiacomo.travaglini@arm.com ->CurrentOsStackTraceExceptTop(1) 37913481Sgiacomo.travaglini@arm.com // Skips the stack frame for this function itself. 38013481Sgiacomo.travaglini@arm.com ); // NOLINT 38113481Sgiacomo.travaglini@arm.com} 38213481Sgiacomo.travaglini@arm.com 38313481Sgiacomo.travaglini@arm.com// Mutex for linked pointers. 38413481Sgiacomo.travaglini@arm.comGTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex); 38513481Sgiacomo.travaglini@arm.com 38613481Sgiacomo.travaglini@arm.com// A copy of all command line arguments. Set by InitGoogleTest(). 38713481Sgiacomo.travaglini@arm.com::std::vector<testing::internal::string> g_argvs; 38813481Sgiacomo.travaglini@arm.com 38913481Sgiacomo.travaglini@arm.comconst ::std::vector<testing::internal::string>& GetArgvs() { 39013481Sgiacomo.travaglini@arm.com#if defined(GTEST_CUSTOM_GET_ARGVS_) 39113481Sgiacomo.travaglini@arm.com return GTEST_CUSTOM_GET_ARGVS_(); 39213481Sgiacomo.travaglini@arm.com#else // defined(GTEST_CUSTOM_GET_ARGVS_) 39313481Sgiacomo.travaglini@arm.com return g_argvs; 39413481Sgiacomo.travaglini@arm.com#endif // defined(GTEST_CUSTOM_GET_ARGVS_) 39513481Sgiacomo.travaglini@arm.com} 39613481Sgiacomo.travaglini@arm.com 39713481Sgiacomo.travaglini@arm.com// Returns the current application's name, removing directory path if that 39813481Sgiacomo.travaglini@arm.com// is present. 39913481Sgiacomo.travaglini@arm.comFilePath GetCurrentExecutableName() { 40013481Sgiacomo.travaglini@arm.com FilePath result; 40113481Sgiacomo.travaglini@arm.com 40213481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 40313481Sgiacomo.travaglini@arm.com result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe")); 40413481Sgiacomo.travaglini@arm.com#else 40513481Sgiacomo.travaglini@arm.com result.Set(FilePath(GetArgvs()[0])); 40613481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 40713481Sgiacomo.travaglini@arm.com 40813481Sgiacomo.travaglini@arm.com return result.RemoveDirectoryName(); 40913481Sgiacomo.travaglini@arm.com} 41013481Sgiacomo.travaglini@arm.com 41113481Sgiacomo.travaglini@arm.com// Functions for processing the gtest_output flag. 41213481Sgiacomo.travaglini@arm.com 41313481Sgiacomo.travaglini@arm.com// Returns the output format, or "" for normal printed output. 41413481Sgiacomo.travaglini@arm.comstd::string UnitTestOptions::GetOutputFormat() { 41513481Sgiacomo.travaglini@arm.com const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); 41613481Sgiacomo.travaglini@arm.com if (gtest_output_flag == NULL) return std::string(""); 41713481Sgiacomo.travaglini@arm.com 41813481Sgiacomo.travaglini@arm.com const char* const colon = strchr(gtest_output_flag, ':'); 41913481Sgiacomo.travaglini@arm.com return (colon == NULL) ? 42013481Sgiacomo.travaglini@arm.com std::string(gtest_output_flag) : 42113481Sgiacomo.travaglini@arm.com std::string(gtest_output_flag, colon - gtest_output_flag); 42213481Sgiacomo.travaglini@arm.com} 42313481Sgiacomo.travaglini@arm.com 42413481Sgiacomo.travaglini@arm.com// Returns the name of the requested output file, or the default if none 42513481Sgiacomo.travaglini@arm.com// was explicitly specified. 42613481Sgiacomo.travaglini@arm.comstd::string UnitTestOptions::GetAbsolutePathToOutputFile() { 42713481Sgiacomo.travaglini@arm.com const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); 42813481Sgiacomo.travaglini@arm.com if (gtest_output_flag == NULL) 42913481Sgiacomo.travaglini@arm.com return ""; 43013481Sgiacomo.travaglini@arm.com 43113481Sgiacomo.travaglini@arm.com const char* const colon = strchr(gtest_output_flag, ':'); 43213481Sgiacomo.travaglini@arm.com if (colon == NULL) 43313481Sgiacomo.travaglini@arm.com return internal::FilePath::ConcatPaths( 43413481Sgiacomo.travaglini@arm.com internal::FilePath( 43513481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()->original_working_dir()), 43613481Sgiacomo.travaglini@arm.com internal::FilePath(kDefaultOutputFile)).string(); 43713481Sgiacomo.travaglini@arm.com 43813481Sgiacomo.travaglini@arm.com internal::FilePath output_name(colon + 1); 43913481Sgiacomo.travaglini@arm.com if (!output_name.IsAbsolutePath()) 44013481Sgiacomo.travaglini@arm.com // TODO(wan@google.com): on Windows \some\path is not an absolute 44113481Sgiacomo.travaglini@arm.com // path (as its meaning depends on the current drive), yet the 44213481Sgiacomo.travaglini@arm.com // following logic for turning it into an absolute path is wrong. 44313481Sgiacomo.travaglini@arm.com // Fix it. 44413481Sgiacomo.travaglini@arm.com output_name = internal::FilePath::ConcatPaths( 44513481Sgiacomo.travaglini@arm.com internal::FilePath(UnitTest::GetInstance()->original_working_dir()), 44613481Sgiacomo.travaglini@arm.com internal::FilePath(colon + 1)); 44713481Sgiacomo.travaglini@arm.com 44813481Sgiacomo.travaglini@arm.com if (!output_name.IsDirectory()) 44913481Sgiacomo.travaglini@arm.com return output_name.string(); 45013481Sgiacomo.travaglini@arm.com 45113481Sgiacomo.travaglini@arm.com internal::FilePath result(internal::FilePath::GenerateUniqueFileName( 45213481Sgiacomo.travaglini@arm.com output_name, internal::GetCurrentExecutableName(), 45313481Sgiacomo.travaglini@arm.com GetOutputFormat().c_str())); 45413481Sgiacomo.travaglini@arm.com return result.string(); 45513481Sgiacomo.travaglini@arm.com} 45613481Sgiacomo.travaglini@arm.com 45713481Sgiacomo.travaglini@arm.com// Returns true iff the wildcard pattern matches the string. The 45813481Sgiacomo.travaglini@arm.com// first ':' or '\0' character in pattern marks the end of it. 45913481Sgiacomo.travaglini@arm.com// 46013481Sgiacomo.travaglini@arm.com// This recursive algorithm isn't very efficient, but is clear and 46113481Sgiacomo.travaglini@arm.com// works well enough for matching test names, which are short. 46213481Sgiacomo.travaglini@arm.combool UnitTestOptions::PatternMatchesString(const char *pattern, 46313481Sgiacomo.travaglini@arm.com const char *str) { 46413481Sgiacomo.travaglini@arm.com switch (*pattern) { 46513481Sgiacomo.travaglini@arm.com case '\0': 46613481Sgiacomo.travaglini@arm.com case ':': // Either ':' or '\0' marks the end of the pattern. 46713481Sgiacomo.travaglini@arm.com return *str == '\0'; 46813481Sgiacomo.travaglini@arm.com case '?': // Matches any single character. 46913481Sgiacomo.travaglini@arm.com return *str != '\0' && PatternMatchesString(pattern + 1, str + 1); 47013481Sgiacomo.travaglini@arm.com case '*': // Matches any string (possibly empty) of characters. 47113481Sgiacomo.travaglini@arm.com return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || 47213481Sgiacomo.travaglini@arm.com PatternMatchesString(pattern + 1, str); 47313481Sgiacomo.travaglini@arm.com default: // Non-special character. Matches itself. 47413481Sgiacomo.travaglini@arm.com return *pattern == *str && 47513481Sgiacomo.travaglini@arm.com PatternMatchesString(pattern + 1, str + 1); 47613481Sgiacomo.travaglini@arm.com } 47713481Sgiacomo.travaglini@arm.com} 47813481Sgiacomo.travaglini@arm.com 47913481Sgiacomo.travaglini@arm.combool UnitTestOptions::MatchesFilter( 48013481Sgiacomo.travaglini@arm.com const std::string& name, const char* filter) { 48113481Sgiacomo.travaglini@arm.com const char *cur_pattern = filter; 48213481Sgiacomo.travaglini@arm.com for (;;) { 48313481Sgiacomo.travaglini@arm.com if (PatternMatchesString(cur_pattern, name.c_str())) { 48413481Sgiacomo.travaglini@arm.com return true; 48513481Sgiacomo.travaglini@arm.com } 48613481Sgiacomo.travaglini@arm.com 48713481Sgiacomo.travaglini@arm.com // Finds the next pattern in the filter. 48813481Sgiacomo.travaglini@arm.com cur_pattern = strchr(cur_pattern, ':'); 48913481Sgiacomo.travaglini@arm.com 49013481Sgiacomo.travaglini@arm.com // Returns if no more pattern can be found. 49113481Sgiacomo.travaglini@arm.com if (cur_pattern == NULL) { 49213481Sgiacomo.travaglini@arm.com return false; 49313481Sgiacomo.travaglini@arm.com } 49413481Sgiacomo.travaglini@arm.com 49513481Sgiacomo.travaglini@arm.com // Skips the pattern separater (the ':' character). 49613481Sgiacomo.travaglini@arm.com cur_pattern++; 49713481Sgiacomo.travaglini@arm.com } 49813481Sgiacomo.travaglini@arm.com} 49913481Sgiacomo.travaglini@arm.com 50013481Sgiacomo.travaglini@arm.com// Returns true iff the user-specified filter matches the test case 50113481Sgiacomo.travaglini@arm.com// name and the test name. 50213481Sgiacomo.travaglini@arm.combool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name, 50313481Sgiacomo.travaglini@arm.com const std::string &test_name) { 50413481Sgiacomo.travaglini@arm.com const std::string& full_name = test_case_name + "." + test_name.c_str(); 50513481Sgiacomo.travaglini@arm.com 50613481Sgiacomo.travaglini@arm.com // Split --gtest_filter at '-', if there is one, to separate into 50713481Sgiacomo.travaglini@arm.com // positive filter and negative filter portions 50813481Sgiacomo.travaglini@arm.com const char* const p = GTEST_FLAG(filter).c_str(); 50913481Sgiacomo.travaglini@arm.com const char* const dash = strchr(p, '-'); 51013481Sgiacomo.travaglini@arm.com std::string positive; 51113481Sgiacomo.travaglini@arm.com std::string negative; 51213481Sgiacomo.travaglini@arm.com if (dash == NULL) { 51313481Sgiacomo.travaglini@arm.com positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter 51413481Sgiacomo.travaglini@arm.com negative = ""; 51513481Sgiacomo.travaglini@arm.com } else { 51613481Sgiacomo.travaglini@arm.com positive = std::string(p, dash); // Everything up to the dash 51713481Sgiacomo.travaglini@arm.com negative = std::string(dash + 1); // Everything after the dash 51813481Sgiacomo.travaglini@arm.com if (positive.empty()) { 51913481Sgiacomo.travaglini@arm.com // Treat '-test1' as the same as '*-test1' 52013481Sgiacomo.travaglini@arm.com positive = kUniversalFilter; 52113481Sgiacomo.travaglini@arm.com } 52213481Sgiacomo.travaglini@arm.com } 52313481Sgiacomo.travaglini@arm.com 52413481Sgiacomo.travaglini@arm.com // A filter is a colon-separated list of patterns. It matches a 52513481Sgiacomo.travaglini@arm.com // test if any pattern in it matches the test. 52613481Sgiacomo.travaglini@arm.com return (MatchesFilter(full_name, positive.c_str()) && 52713481Sgiacomo.travaglini@arm.com !MatchesFilter(full_name, negative.c_str())); 52813481Sgiacomo.travaglini@arm.com} 52913481Sgiacomo.travaglini@arm.com 53013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_SEH 53113481Sgiacomo.travaglini@arm.com// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the 53213481Sgiacomo.travaglini@arm.com// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. 53313481Sgiacomo.travaglini@arm.com// This function is useful as an __except condition. 53413481Sgiacomo.travaglini@arm.comint UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { 53513481Sgiacomo.travaglini@arm.com // Google Test should handle a SEH exception if: 53613481Sgiacomo.travaglini@arm.com // 1. the user wants it to, AND 53713481Sgiacomo.travaglini@arm.com // 2. this is not a breakpoint exception, AND 53813481Sgiacomo.travaglini@arm.com // 3. this is not a C++ exception (VC++ implements them via SEH, 53913481Sgiacomo.travaglini@arm.com // apparently). 54013481Sgiacomo.travaglini@arm.com // 54113481Sgiacomo.travaglini@arm.com // SEH exception code for C++ exceptions. 54213481Sgiacomo.travaglini@arm.com // (see http://support.microsoft.com/kb/185294 for more information). 54313481Sgiacomo.travaglini@arm.com const DWORD kCxxExceptionCode = 0xe06d7363; 54413481Sgiacomo.travaglini@arm.com 54513481Sgiacomo.travaglini@arm.com bool should_handle = true; 54613481Sgiacomo.travaglini@arm.com 54713481Sgiacomo.travaglini@arm.com if (!GTEST_FLAG(catch_exceptions)) 54813481Sgiacomo.travaglini@arm.com should_handle = false; 54913481Sgiacomo.travaglini@arm.com else if (exception_code == EXCEPTION_BREAKPOINT) 55013481Sgiacomo.travaglini@arm.com should_handle = false; 55113481Sgiacomo.travaglini@arm.com else if (exception_code == kCxxExceptionCode) 55213481Sgiacomo.travaglini@arm.com should_handle = false; 55313481Sgiacomo.travaglini@arm.com 55413481Sgiacomo.travaglini@arm.com return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; 55513481Sgiacomo.travaglini@arm.com} 55613481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_SEH 55713481Sgiacomo.travaglini@arm.com 55813481Sgiacomo.travaglini@arm.com} // namespace internal 55913481Sgiacomo.travaglini@arm.com 56013481Sgiacomo.travaglini@arm.com// The c'tor sets this object as the test part result reporter used by 56113481Sgiacomo.travaglini@arm.com// Google Test. The 'result' parameter specifies where to report the 56213481Sgiacomo.travaglini@arm.com// results. Intercepts only failures from the current thread. 56313481Sgiacomo.travaglini@arm.comScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( 56413481Sgiacomo.travaglini@arm.com TestPartResultArray* result) 56513481Sgiacomo.travaglini@arm.com : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), 56613481Sgiacomo.travaglini@arm.com result_(result) { 56713481Sgiacomo.travaglini@arm.com Init(); 56813481Sgiacomo.travaglini@arm.com} 56913481Sgiacomo.travaglini@arm.com 57013481Sgiacomo.travaglini@arm.com// The c'tor sets this object as the test part result reporter used by 57113481Sgiacomo.travaglini@arm.com// Google Test. The 'result' parameter specifies where to report the 57213481Sgiacomo.travaglini@arm.com// results. 57313481Sgiacomo.travaglini@arm.comScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( 57413481Sgiacomo.travaglini@arm.com InterceptMode intercept_mode, TestPartResultArray* result) 57513481Sgiacomo.travaglini@arm.com : intercept_mode_(intercept_mode), 57613481Sgiacomo.travaglini@arm.com result_(result) { 57713481Sgiacomo.travaglini@arm.com Init(); 57813481Sgiacomo.travaglini@arm.com} 57913481Sgiacomo.travaglini@arm.com 58013481Sgiacomo.travaglini@arm.comvoid ScopedFakeTestPartResultReporter::Init() { 58113481Sgiacomo.travaglini@arm.com internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 58213481Sgiacomo.travaglini@arm.com if (intercept_mode_ == INTERCEPT_ALL_THREADS) { 58313481Sgiacomo.travaglini@arm.com old_reporter_ = impl->GetGlobalTestPartResultReporter(); 58413481Sgiacomo.travaglini@arm.com impl->SetGlobalTestPartResultReporter(this); 58513481Sgiacomo.travaglini@arm.com } else { 58613481Sgiacomo.travaglini@arm.com old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); 58713481Sgiacomo.travaglini@arm.com impl->SetTestPartResultReporterForCurrentThread(this); 58813481Sgiacomo.travaglini@arm.com } 58913481Sgiacomo.travaglini@arm.com} 59013481Sgiacomo.travaglini@arm.com 59113481Sgiacomo.travaglini@arm.com// The d'tor restores the test part result reporter used by Google Test 59213481Sgiacomo.travaglini@arm.com// before. 59313481Sgiacomo.travaglini@arm.comScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { 59413481Sgiacomo.travaglini@arm.com internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 59513481Sgiacomo.travaglini@arm.com if (intercept_mode_ == INTERCEPT_ALL_THREADS) { 59613481Sgiacomo.travaglini@arm.com impl->SetGlobalTestPartResultReporter(old_reporter_); 59713481Sgiacomo.travaglini@arm.com } else { 59813481Sgiacomo.travaglini@arm.com impl->SetTestPartResultReporterForCurrentThread(old_reporter_); 59913481Sgiacomo.travaglini@arm.com } 60013481Sgiacomo.travaglini@arm.com} 60113481Sgiacomo.travaglini@arm.com 60213481Sgiacomo.travaglini@arm.com// Increments the test part result count and remembers the result. 60313481Sgiacomo.travaglini@arm.com// This method is from the TestPartResultReporterInterface interface. 60413481Sgiacomo.travaglini@arm.comvoid ScopedFakeTestPartResultReporter::ReportTestPartResult( 60513481Sgiacomo.travaglini@arm.com const TestPartResult& result) { 60613481Sgiacomo.travaglini@arm.com result_->Append(result); 60713481Sgiacomo.travaglini@arm.com} 60813481Sgiacomo.travaglini@arm.com 60913481Sgiacomo.travaglini@arm.comnamespace internal { 61013481Sgiacomo.travaglini@arm.com 61113481Sgiacomo.travaglini@arm.com// Returns the type ID of ::testing::Test. We should always call this 61213481Sgiacomo.travaglini@arm.com// instead of GetTypeId< ::testing::Test>() to get the type ID of 61313481Sgiacomo.travaglini@arm.com// testing::Test. This is to work around a suspected linker bug when 61413481Sgiacomo.travaglini@arm.com// using Google Test as a framework on Mac OS X. The bug causes 61513481Sgiacomo.travaglini@arm.com// GetTypeId< ::testing::Test>() to return different values depending 61613481Sgiacomo.travaglini@arm.com// on whether the call is from the Google Test framework itself or 61713481Sgiacomo.travaglini@arm.com// from user test code. GetTestTypeId() is guaranteed to always 61813481Sgiacomo.travaglini@arm.com// return the same value, as it always calls GetTypeId<>() from the 61913481Sgiacomo.travaglini@arm.com// gtest.cc, which is within the Google Test framework. 62013481Sgiacomo.travaglini@arm.comTypeId GetTestTypeId() { 62113481Sgiacomo.travaglini@arm.com return GetTypeId<Test>(); 62213481Sgiacomo.travaglini@arm.com} 62313481Sgiacomo.travaglini@arm.com 62413481Sgiacomo.travaglini@arm.com// The value of GetTestTypeId() as seen from within the Google Test 62513481Sgiacomo.travaglini@arm.com// library. This is solely for testing GetTestTypeId(). 62613481Sgiacomo.travaglini@arm.comextern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); 62713481Sgiacomo.travaglini@arm.com 62813481Sgiacomo.travaglini@arm.com// This predicate-formatter checks that 'results' contains a test part 62913481Sgiacomo.travaglini@arm.com// failure of the given type and that the failure message contains the 63013481Sgiacomo.travaglini@arm.com// given substring. 63113481Sgiacomo.travaglini@arm.comAssertionResult HasOneFailure(const char* /* results_expr */, 63213481Sgiacomo.travaglini@arm.com const char* /* type_expr */, 63313481Sgiacomo.travaglini@arm.com const char* /* substr_expr */, 63413481Sgiacomo.travaglini@arm.com const TestPartResultArray& results, 63513481Sgiacomo.travaglini@arm.com TestPartResult::Type type, 63613481Sgiacomo.travaglini@arm.com const string& substr) { 63713481Sgiacomo.travaglini@arm.com const std::string expected(type == TestPartResult::kFatalFailure ? 63813481Sgiacomo.travaglini@arm.com "1 fatal failure" : 63913481Sgiacomo.travaglini@arm.com "1 non-fatal failure"); 64013481Sgiacomo.travaglini@arm.com Message msg; 64113481Sgiacomo.travaglini@arm.com if (results.size() != 1) { 64213481Sgiacomo.travaglini@arm.com msg << "Expected: " << expected << "\n" 64313481Sgiacomo.travaglini@arm.com << " Actual: " << results.size() << " failures"; 64413481Sgiacomo.travaglini@arm.com for (int i = 0; i < results.size(); i++) { 64513481Sgiacomo.travaglini@arm.com msg << "\n" << results.GetTestPartResult(i); 64613481Sgiacomo.travaglini@arm.com } 64713481Sgiacomo.travaglini@arm.com return AssertionFailure() << msg; 64813481Sgiacomo.travaglini@arm.com } 64913481Sgiacomo.travaglini@arm.com 65013481Sgiacomo.travaglini@arm.com const TestPartResult& r = results.GetTestPartResult(0); 65113481Sgiacomo.travaglini@arm.com if (r.type() != type) { 65213481Sgiacomo.travaglini@arm.com return AssertionFailure() << "Expected: " << expected << "\n" 65313481Sgiacomo.travaglini@arm.com << " Actual:\n" 65413481Sgiacomo.travaglini@arm.com << r; 65513481Sgiacomo.travaglini@arm.com } 65613481Sgiacomo.travaglini@arm.com 65713481Sgiacomo.travaglini@arm.com if (strstr(r.message(), substr.c_str()) == NULL) { 65813481Sgiacomo.travaglini@arm.com return AssertionFailure() << "Expected: " << expected << " containing \"" 65913481Sgiacomo.travaglini@arm.com << substr << "\"\n" 66013481Sgiacomo.travaglini@arm.com << " Actual:\n" 66113481Sgiacomo.travaglini@arm.com << r; 66213481Sgiacomo.travaglini@arm.com } 66313481Sgiacomo.travaglini@arm.com 66413481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 66513481Sgiacomo.travaglini@arm.com} 66613481Sgiacomo.travaglini@arm.com 66713481Sgiacomo.travaglini@arm.com// The constructor of SingleFailureChecker remembers where to look up 66813481Sgiacomo.travaglini@arm.com// test part results, what type of failure we expect, and what 66913481Sgiacomo.travaglini@arm.com// substring the failure message should contain. 67013481Sgiacomo.travaglini@arm.comSingleFailureChecker:: SingleFailureChecker( 67113481Sgiacomo.travaglini@arm.com const TestPartResultArray* results, 67213481Sgiacomo.travaglini@arm.com TestPartResult::Type type, 67313481Sgiacomo.travaglini@arm.com const string& substr) 67413481Sgiacomo.travaglini@arm.com : results_(results), 67513481Sgiacomo.travaglini@arm.com type_(type), 67613481Sgiacomo.travaglini@arm.com substr_(substr) {} 67713481Sgiacomo.travaglini@arm.com 67813481Sgiacomo.travaglini@arm.com// The destructor of SingleFailureChecker verifies that the given 67913481Sgiacomo.travaglini@arm.com// TestPartResultArray contains exactly one failure that has the given 68013481Sgiacomo.travaglini@arm.com// type and contains the given substring. If that's not the case, a 68113481Sgiacomo.travaglini@arm.com// non-fatal failure will be generated. 68213481Sgiacomo.travaglini@arm.comSingleFailureChecker::~SingleFailureChecker() { 68313481Sgiacomo.travaglini@arm.com EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); 68413481Sgiacomo.travaglini@arm.com} 68513481Sgiacomo.travaglini@arm.com 68613481Sgiacomo.travaglini@arm.comDefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( 68713481Sgiacomo.travaglini@arm.com UnitTestImpl* unit_test) : unit_test_(unit_test) {} 68813481Sgiacomo.travaglini@arm.com 68913481Sgiacomo.travaglini@arm.comvoid DefaultGlobalTestPartResultReporter::ReportTestPartResult( 69013481Sgiacomo.travaglini@arm.com const TestPartResult& result) { 69113481Sgiacomo.travaglini@arm.com unit_test_->current_test_result()->AddTestPartResult(result); 69213481Sgiacomo.travaglini@arm.com unit_test_->listeners()->repeater()->OnTestPartResult(result); 69313481Sgiacomo.travaglini@arm.com} 69413481Sgiacomo.travaglini@arm.com 69513481Sgiacomo.travaglini@arm.comDefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( 69613481Sgiacomo.travaglini@arm.com UnitTestImpl* unit_test) : unit_test_(unit_test) {} 69713481Sgiacomo.travaglini@arm.com 69813481Sgiacomo.travaglini@arm.comvoid DefaultPerThreadTestPartResultReporter::ReportTestPartResult( 69913481Sgiacomo.travaglini@arm.com const TestPartResult& result) { 70013481Sgiacomo.travaglini@arm.com unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); 70113481Sgiacomo.travaglini@arm.com} 70213481Sgiacomo.travaglini@arm.com 70313481Sgiacomo.travaglini@arm.com// Returns the global test part result reporter. 70413481Sgiacomo.travaglini@arm.comTestPartResultReporterInterface* 70513481Sgiacomo.travaglini@arm.comUnitTestImpl::GetGlobalTestPartResultReporter() { 70613481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&global_test_part_result_reporter_mutex_); 70713481Sgiacomo.travaglini@arm.com return global_test_part_result_repoter_; 70813481Sgiacomo.travaglini@arm.com} 70913481Sgiacomo.travaglini@arm.com 71013481Sgiacomo.travaglini@arm.com// Sets the global test part result reporter. 71113481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::SetGlobalTestPartResultReporter( 71213481Sgiacomo.travaglini@arm.com TestPartResultReporterInterface* reporter) { 71313481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&global_test_part_result_reporter_mutex_); 71413481Sgiacomo.travaglini@arm.com global_test_part_result_repoter_ = reporter; 71513481Sgiacomo.travaglini@arm.com} 71613481Sgiacomo.travaglini@arm.com 71713481Sgiacomo.travaglini@arm.com// Returns the test part result reporter for the current thread. 71813481Sgiacomo.travaglini@arm.comTestPartResultReporterInterface* 71913481Sgiacomo.travaglini@arm.comUnitTestImpl::GetTestPartResultReporterForCurrentThread() { 72013481Sgiacomo.travaglini@arm.com return per_thread_test_part_result_reporter_.get(); 72113481Sgiacomo.travaglini@arm.com} 72213481Sgiacomo.travaglini@arm.com 72313481Sgiacomo.travaglini@arm.com// Sets the test part result reporter for the current thread. 72413481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::SetTestPartResultReporterForCurrentThread( 72513481Sgiacomo.travaglini@arm.com TestPartResultReporterInterface* reporter) { 72613481Sgiacomo.travaglini@arm.com per_thread_test_part_result_reporter_.set(reporter); 72713481Sgiacomo.travaglini@arm.com} 72813481Sgiacomo.travaglini@arm.com 72913481Sgiacomo.travaglini@arm.com// Gets the number of successful test cases. 73013481Sgiacomo.travaglini@arm.comint UnitTestImpl::successful_test_case_count() const { 73113481Sgiacomo.travaglini@arm.com return CountIf(test_cases_, TestCasePassed); 73213481Sgiacomo.travaglini@arm.com} 73313481Sgiacomo.travaglini@arm.com 73413481Sgiacomo.travaglini@arm.com// Gets the number of failed test cases. 73513481Sgiacomo.travaglini@arm.comint UnitTestImpl::failed_test_case_count() const { 73613481Sgiacomo.travaglini@arm.com return CountIf(test_cases_, TestCaseFailed); 73713481Sgiacomo.travaglini@arm.com} 73813481Sgiacomo.travaglini@arm.com 73913481Sgiacomo.travaglini@arm.com// Gets the number of all test cases. 74013481Sgiacomo.travaglini@arm.comint UnitTestImpl::total_test_case_count() const { 74113481Sgiacomo.travaglini@arm.com return static_cast<int>(test_cases_.size()); 74213481Sgiacomo.travaglini@arm.com} 74313481Sgiacomo.travaglini@arm.com 74413481Sgiacomo.travaglini@arm.com// Gets the number of all test cases that contain at least one test 74513481Sgiacomo.travaglini@arm.com// that should run. 74613481Sgiacomo.travaglini@arm.comint UnitTestImpl::test_case_to_run_count() const { 74713481Sgiacomo.travaglini@arm.com return CountIf(test_cases_, ShouldRunTestCase); 74813481Sgiacomo.travaglini@arm.com} 74913481Sgiacomo.travaglini@arm.com 75013481Sgiacomo.travaglini@arm.com// Gets the number of successful tests. 75113481Sgiacomo.travaglini@arm.comint UnitTestImpl::successful_test_count() const { 75213481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); 75313481Sgiacomo.travaglini@arm.com} 75413481Sgiacomo.travaglini@arm.com 75513481Sgiacomo.travaglini@arm.com// Gets the number of failed tests. 75613481Sgiacomo.travaglini@arm.comint UnitTestImpl::failed_test_count() const { 75713481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); 75813481Sgiacomo.travaglini@arm.com} 75913481Sgiacomo.travaglini@arm.com 76013481Sgiacomo.travaglini@arm.com// Gets the number of disabled tests that will be reported in the XML report. 76113481Sgiacomo.travaglini@arm.comint UnitTestImpl::reportable_disabled_test_count() const { 76213481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, 76313481Sgiacomo.travaglini@arm.com &TestCase::reportable_disabled_test_count); 76413481Sgiacomo.travaglini@arm.com} 76513481Sgiacomo.travaglini@arm.com 76613481Sgiacomo.travaglini@arm.com// Gets the number of disabled tests. 76713481Sgiacomo.travaglini@arm.comint UnitTestImpl::disabled_test_count() const { 76813481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); 76913481Sgiacomo.travaglini@arm.com} 77013481Sgiacomo.travaglini@arm.com 77113481Sgiacomo.travaglini@arm.com// Gets the number of tests to be printed in the XML report. 77213481Sgiacomo.travaglini@arm.comint UnitTestImpl::reportable_test_count() const { 77313481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count); 77413481Sgiacomo.travaglini@arm.com} 77513481Sgiacomo.travaglini@arm.com 77613481Sgiacomo.travaglini@arm.com// Gets the number of all tests. 77713481Sgiacomo.travaglini@arm.comint UnitTestImpl::total_test_count() const { 77813481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); 77913481Sgiacomo.travaglini@arm.com} 78013481Sgiacomo.travaglini@arm.com 78113481Sgiacomo.travaglini@arm.com// Gets the number of tests that should run. 78213481Sgiacomo.travaglini@arm.comint UnitTestImpl::test_to_run_count() const { 78313481Sgiacomo.travaglini@arm.com return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); 78413481Sgiacomo.travaglini@arm.com} 78513481Sgiacomo.travaglini@arm.com 78613481Sgiacomo.travaglini@arm.com// Returns the current OS stack trace as an std::string. 78713481Sgiacomo.travaglini@arm.com// 78813481Sgiacomo.travaglini@arm.com// The maximum number of stack frames to be included is specified by 78913481Sgiacomo.travaglini@arm.com// the gtest_stack_trace_depth flag. The skip_count parameter 79013481Sgiacomo.travaglini@arm.com// specifies the number of top frames to be skipped, which doesn't 79113481Sgiacomo.travaglini@arm.com// count against the number of frames to be included. 79213481Sgiacomo.travaglini@arm.com// 79313481Sgiacomo.travaglini@arm.com// For example, if Foo() calls Bar(), which in turn calls 79413481Sgiacomo.travaglini@arm.com// CurrentOsStackTraceExceptTop(1), Foo() will be included in the 79513481Sgiacomo.travaglini@arm.com// trace but Bar() and CurrentOsStackTraceExceptTop() won't. 79613481Sgiacomo.travaglini@arm.comstd::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { 79713481Sgiacomo.travaglini@arm.com return os_stack_trace_getter()->CurrentStackTrace( 79813481Sgiacomo.travaglini@arm.com static_cast<int>(GTEST_FLAG(stack_trace_depth)), 79913481Sgiacomo.travaglini@arm.com skip_count + 1 80013481Sgiacomo.travaglini@arm.com // Skips the user-specified number of frames plus this function 80113481Sgiacomo.travaglini@arm.com // itself. 80213481Sgiacomo.travaglini@arm.com ); // NOLINT 80313481Sgiacomo.travaglini@arm.com} 80413481Sgiacomo.travaglini@arm.com 80513481Sgiacomo.travaglini@arm.com// Returns the current time in milliseconds. 80613481Sgiacomo.travaglini@arm.comTimeInMillis GetTimeInMillis() { 80713481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) 80813481Sgiacomo.travaglini@arm.com // Difference between 1970-01-01 and 1601-01-01 in milliseconds. 80913481Sgiacomo.travaglini@arm.com // http://analogous.blogspot.com/2005/04/epoch.html 81013481Sgiacomo.travaglini@arm.com const TimeInMillis kJavaEpochToWinFileTimeDelta = 81113481Sgiacomo.travaglini@arm.com static_cast<TimeInMillis>(116444736UL) * 100000UL; 81213481Sgiacomo.travaglini@arm.com const DWORD kTenthMicrosInMilliSecond = 10000; 81313481Sgiacomo.travaglini@arm.com 81413481Sgiacomo.travaglini@arm.com SYSTEMTIME now_systime; 81513481Sgiacomo.travaglini@arm.com FILETIME now_filetime; 81613481Sgiacomo.travaglini@arm.com ULARGE_INTEGER now_int64; 81713481Sgiacomo.travaglini@arm.com // TODO(kenton@google.com): Shouldn't this just use 81813481Sgiacomo.travaglini@arm.com // GetSystemTimeAsFileTime()? 81913481Sgiacomo.travaglini@arm.com GetSystemTime(&now_systime); 82013481Sgiacomo.travaglini@arm.com if (SystemTimeToFileTime(&now_systime, &now_filetime)) { 82113481Sgiacomo.travaglini@arm.com now_int64.LowPart = now_filetime.dwLowDateTime; 82213481Sgiacomo.travaglini@arm.com now_int64.HighPart = now_filetime.dwHighDateTime; 82313481Sgiacomo.travaglini@arm.com now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - 82413481Sgiacomo.travaglini@arm.com kJavaEpochToWinFileTimeDelta; 82513481Sgiacomo.travaglini@arm.com return now_int64.QuadPart; 82613481Sgiacomo.travaglini@arm.com } 82713481Sgiacomo.travaglini@arm.com return 0; 82813481Sgiacomo.travaglini@arm.com#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ 82913481Sgiacomo.travaglini@arm.com __timeb64 now; 83013481Sgiacomo.travaglini@arm.com 83113481Sgiacomo.travaglini@arm.com // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 83213481Sgiacomo.travaglini@arm.com // (deprecated function) there. 83313481Sgiacomo.travaglini@arm.com // TODO(kenton@google.com): Use GetTickCount()? Or use 83413481Sgiacomo.travaglini@arm.com // SystemTimeToFileTime() 83513481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996) 83613481Sgiacomo.travaglini@arm.com _ftime64(&now); 83713481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_POP_() 83813481Sgiacomo.travaglini@arm.com 83913481Sgiacomo.travaglini@arm.com return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; 84013481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_GETTIMEOFDAY_ 84113481Sgiacomo.travaglini@arm.com struct timeval now; 84213481Sgiacomo.travaglini@arm.com gettimeofday(&now, NULL); 84313481Sgiacomo.travaglini@arm.com return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000; 84413481Sgiacomo.travaglini@arm.com#else 84513481Sgiacomo.travaglini@arm.com# error "Don't know how to get the current time on your system." 84613481Sgiacomo.travaglini@arm.com#endif 84713481Sgiacomo.travaglini@arm.com} 84813481Sgiacomo.travaglini@arm.com 84913481Sgiacomo.travaglini@arm.com// Utilities 85013481Sgiacomo.travaglini@arm.com 85113481Sgiacomo.travaglini@arm.com// class String. 85213481Sgiacomo.travaglini@arm.com 85313481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE 85413481Sgiacomo.travaglini@arm.com// Creates a UTF-16 wide string from the given ANSI string, allocating 85513481Sgiacomo.travaglini@arm.com// memory using new. The caller is responsible for deleting the return 85613481Sgiacomo.travaglini@arm.com// value using delete[]. Returns the wide string, or NULL if the 85713481Sgiacomo.travaglini@arm.com// input is NULL. 85813481Sgiacomo.travaglini@arm.comLPCWSTR String::AnsiToUtf16(const char* ansi) { 85913481Sgiacomo.travaglini@arm.com if (!ansi) return NULL; 86013481Sgiacomo.travaglini@arm.com const int length = strlen(ansi); 86113481Sgiacomo.travaglini@arm.com const int unicode_length = 86213481Sgiacomo.travaglini@arm.com MultiByteToWideChar(CP_ACP, 0, ansi, length, 86313481Sgiacomo.travaglini@arm.com NULL, 0); 86413481Sgiacomo.travaglini@arm.com WCHAR* unicode = new WCHAR[unicode_length + 1]; 86513481Sgiacomo.travaglini@arm.com MultiByteToWideChar(CP_ACP, 0, ansi, length, 86613481Sgiacomo.travaglini@arm.com unicode, unicode_length); 86713481Sgiacomo.travaglini@arm.com unicode[unicode_length] = 0; 86813481Sgiacomo.travaglini@arm.com return unicode; 86913481Sgiacomo.travaglini@arm.com} 87013481Sgiacomo.travaglini@arm.com 87113481Sgiacomo.travaglini@arm.com// Creates an ANSI string from the given wide string, allocating 87213481Sgiacomo.travaglini@arm.com// memory using new. The caller is responsible for deleting the return 87313481Sgiacomo.travaglini@arm.com// value using delete[]. Returns the ANSI string, or NULL if the 87413481Sgiacomo.travaglini@arm.com// input is NULL. 87513481Sgiacomo.travaglini@arm.comconst char* String::Utf16ToAnsi(LPCWSTR utf16_str) { 87613481Sgiacomo.travaglini@arm.com if (!utf16_str) return NULL; 87713481Sgiacomo.travaglini@arm.com const int ansi_length = 87813481Sgiacomo.travaglini@arm.com WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, 87913481Sgiacomo.travaglini@arm.com NULL, 0, NULL, NULL); 88013481Sgiacomo.travaglini@arm.com char* ansi = new char[ansi_length + 1]; 88113481Sgiacomo.travaglini@arm.com WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, 88213481Sgiacomo.travaglini@arm.com ansi, ansi_length, NULL, NULL); 88313481Sgiacomo.travaglini@arm.com ansi[ansi_length] = 0; 88413481Sgiacomo.travaglini@arm.com return ansi; 88513481Sgiacomo.travaglini@arm.com} 88613481Sgiacomo.travaglini@arm.com 88713481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS_MOBILE 88813481Sgiacomo.travaglini@arm.com 88913481Sgiacomo.travaglini@arm.com// Compares two C strings. Returns true iff they have the same content. 89013481Sgiacomo.travaglini@arm.com// 89113481Sgiacomo.travaglini@arm.com// Unlike strcmp(), this function can handle NULL argument(s). A NULL 89213481Sgiacomo.travaglini@arm.com// C string is considered different to any non-NULL C string, 89313481Sgiacomo.travaglini@arm.com// including the empty string. 89413481Sgiacomo.travaglini@arm.combool String::CStringEquals(const char * lhs, const char * rhs) { 89513481Sgiacomo.travaglini@arm.com if ( lhs == NULL ) return rhs == NULL; 89613481Sgiacomo.travaglini@arm.com 89713481Sgiacomo.travaglini@arm.com if ( rhs == NULL ) return false; 89813481Sgiacomo.travaglini@arm.com 89913481Sgiacomo.travaglini@arm.com return strcmp(lhs, rhs) == 0; 90013481Sgiacomo.travaglini@arm.com} 90113481Sgiacomo.travaglini@arm.com 90213481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 90313481Sgiacomo.travaglini@arm.com 90413481Sgiacomo.travaglini@arm.com// Converts an array of wide chars to a narrow string using the UTF-8 90513481Sgiacomo.travaglini@arm.com// encoding, and streams the result to the given Message object. 90613481Sgiacomo.travaglini@arm.comstatic void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, 90713481Sgiacomo.travaglini@arm.com Message* msg) { 90813481Sgiacomo.travaglini@arm.com for (size_t i = 0; i != length; ) { // NOLINT 90913481Sgiacomo.travaglini@arm.com if (wstr[i] != L'\0') { 91013481Sgiacomo.travaglini@arm.com *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i)); 91113481Sgiacomo.travaglini@arm.com while (i != length && wstr[i] != L'\0') 91213481Sgiacomo.travaglini@arm.com i++; 91313481Sgiacomo.travaglini@arm.com } else { 91413481Sgiacomo.travaglini@arm.com *msg << '\0'; 91513481Sgiacomo.travaglini@arm.com i++; 91613481Sgiacomo.travaglini@arm.com } 91713481Sgiacomo.travaglini@arm.com } 91813481Sgiacomo.travaglini@arm.com} 91913481Sgiacomo.travaglini@arm.com 92013481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 92113481Sgiacomo.travaglini@arm.com 92213481Sgiacomo.travaglini@arm.comvoid SplitString(const ::std::string& str, char delimiter, 92313481Sgiacomo.travaglini@arm.com ::std::vector< ::std::string>* dest) { 92413481Sgiacomo.travaglini@arm.com ::std::vector< ::std::string> parsed; 92513481Sgiacomo.travaglini@arm.com ::std::string::size_type pos = 0; 92613481Sgiacomo.travaglini@arm.com while (::testing::internal::AlwaysTrue()) { 92713481Sgiacomo.travaglini@arm.com const ::std::string::size_type colon = str.find(delimiter, pos); 92813481Sgiacomo.travaglini@arm.com if (colon == ::std::string::npos) { 92913481Sgiacomo.travaglini@arm.com parsed.push_back(str.substr(pos)); 93013481Sgiacomo.travaglini@arm.com break; 93113481Sgiacomo.travaglini@arm.com } else { 93213481Sgiacomo.travaglini@arm.com parsed.push_back(str.substr(pos, colon - pos)); 93313481Sgiacomo.travaglini@arm.com pos = colon + 1; 93413481Sgiacomo.travaglini@arm.com } 93513481Sgiacomo.travaglini@arm.com } 93613481Sgiacomo.travaglini@arm.com dest->swap(parsed); 93713481Sgiacomo.travaglini@arm.com} 93813481Sgiacomo.travaglini@arm.com 93913481Sgiacomo.travaglini@arm.com} // namespace internal 94013481Sgiacomo.travaglini@arm.com 94113481Sgiacomo.travaglini@arm.com// Constructs an empty Message. 94213481Sgiacomo.travaglini@arm.com// We allocate the stringstream separately because otherwise each use of 94313481Sgiacomo.travaglini@arm.com// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's 94413481Sgiacomo.travaglini@arm.com// stack frame leading to huge stack frames in some cases; gcc does not reuse 94513481Sgiacomo.travaglini@arm.com// the stack space. 94613481Sgiacomo.travaglini@arm.comMessage::Message() : ss_(new ::std::stringstream) { 94713481Sgiacomo.travaglini@arm.com // By default, we want there to be enough precision when printing 94813481Sgiacomo.travaglini@arm.com // a double to a Message. 94913481Sgiacomo.travaglini@arm.com *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2); 95013481Sgiacomo.travaglini@arm.com} 95113481Sgiacomo.travaglini@arm.com 95213481Sgiacomo.travaglini@arm.com// These two overloads allow streaming a wide C string to a Message 95313481Sgiacomo.travaglini@arm.com// using the UTF-8 encoding. 95413481Sgiacomo.travaglini@arm.comMessage& Message::operator <<(const wchar_t* wide_c_str) { 95513481Sgiacomo.travaglini@arm.com return *this << internal::String::ShowWideCString(wide_c_str); 95613481Sgiacomo.travaglini@arm.com} 95713481Sgiacomo.travaglini@arm.comMessage& Message::operator <<(wchar_t* wide_c_str) { 95813481Sgiacomo.travaglini@arm.com return *this << internal::String::ShowWideCString(wide_c_str); 95913481Sgiacomo.travaglini@arm.com} 96013481Sgiacomo.travaglini@arm.com 96113481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_WSTRING 96213481Sgiacomo.travaglini@arm.com// Converts the given wide string to a narrow string using the UTF-8 96313481Sgiacomo.travaglini@arm.com// encoding, and streams the result to this Message object. 96413481Sgiacomo.travaglini@arm.comMessage& Message::operator <<(const ::std::wstring& wstr) { 96513481Sgiacomo.travaglini@arm.com internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); 96613481Sgiacomo.travaglini@arm.com return *this; 96713481Sgiacomo.travaglini@arm.com} 96813481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STD_WSTRING 96913481Sgiacomo.travaglini@arm.com 97013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_WSTRING 97113481Sgiacomo.travaglini@arm.com// Converts the given wide string to a narrow string using the UTF-8 97213481Sgiacomo.travaglini@arm.com// encoding, and streams the result to this Message object. 97313481Sgiacomo.travaglini@arm.comMessage& Message::operator <<(const ::wstring& wstr) { 97413481Sgiacomo.travaglini@arm.com internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); 97513481Sgiacomo.travaglini@arm.com return *this; 97613481Sgiacomo.travaglini@arm.com} 97713481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_WSTRING 97813481Sgiacomo.travaglini@arm.com 97913481Sgiacomo.travaglini@arm.com// Gets the text streamed to this object so far as an std::string. 98013481Sgiacomo.travaglini@arm.com// Each '\0' character in the buffer is replaced with "\\0". 98113481Sgiacomo.travaglini@arm.comstd::string Message::GetString() const { 98213481Sgiacomo.travaglini@arm.com return internal::StringStreamToString(ss_.get()); 98313481Sgiacomo.travaglini@arm.com} 98413481Sgiacomo.travaglini@arm.com 98513481Sgiacomo.travaglini@arm.com// AssertionResult constructors. 98613481Sgiacomo.travaglini@arm.com// Used in EXPECT_TRUE/FALSE(assertion_result). 98713481Sgiacomo.travaglini@arm.comAssertionResult::AssertionResult(const AssertionResult& other) 98813481Sgiacomo.travaglini@arm.com : success_(other.success_), 98913481Sgiacomo.travaglini@arm.com message_(other.message_.get() != NULL ? 99013481Sgiacomo.travaglini@arm.com new ::std::string(*other.message_) : 99113481Sgiacomo.travaglini@arm.com static_cast< ::std::string*>(NULL)) { 99213481Sgiacomo.travaglini@arm.com} 99313481Sgiacomo.travaglini@arm.com 99413481Sgiacomo.travaglini@arm.com// Swaps two AssertionResults. 99513481Sgiacomo.travaglini@arm.comvoid AssertionResult::swap(AssertionResult& other) { 99613481Sgiacomo.travaglini@arm.com using std::swap; 99713481Sgiacomo.travaglini@arm.com swap(success_, other.success_); 99813481Sgiacomo.travaglini@arm.com swap(message_, other.message_); 99913481Sgiacomo.travaglini@arm.com} 100013481Sgiacomo.travaglini@arm.com 100113481Sgiacomo.travaglini@arm.com// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. 100213481Sgiacomo.travaglini@arm.comAssertionResult AssertionResult::operator!() const { 100313481Sgiacomo.travaglini@arm.com AssertionResult negation(!success_); 100413481Sgiacomo.travaglini@arm.com if (message_.get() != NULL) 100513481Sgiacomo.travaglini@arm.com negation << *message_; 100613481Sgiacomo.travaglini@arm.com return negation; 100713481Sgiacomo.travaglini@arm.com} 100813481Sgiacomo.travaglini@arm.com 100913481Sgiacomo.travaglini@arm.com// Makes a successful assertion result. 101013481Sgiacomo.travaglini@arm.comAssertionResult AssertionSuccess() { 101113481Sgiacomo.travaglini@arm.com return AssertionResult(true); 101213481Sgiacomo.travaglini@arm.com} 101313481Sgiacomo.travaglini@arm.com 101413481Sgiacomo.travaglini@arm.com// Makes a failed assertion result. 101513481Sgiacomo.travaglini@arm.comAssertionResult AssertionFailure() { 101613481Sgiacomo.travaglini@arm.com return AssertionResult(false); 101713481Sgiacomo.travaglini@arm.com} 101813481Sgiacomo.travaglini@arm.com 101913481Sgiacomo.travaglini@arm.com// Makes a failed assertion result with the given failure message. 102013481Sgiacomo.travaglini@arm.com// Deprecated; use AssertionFailure() << message. 102113481Sgiacomo.travaglini@arm.comAssertionResult AssertionFailure(const Message& message) { 102213481Sgiacomo.travaglini@arm.com return AssertionFailure() << message; 102313481Sgiacomo.travaglini@arm.com} 102413481Sgiacomo.travaglini@arm.com 102513481Sgiacomo.travaglini@arm.comnamespace internal { 102613481Sgiacomo.travaglini@arm.com 102713481Sgiacomo.travaglini@arm.comnamespace edit_distance { 102813481Sgiacomo.travaglini@arm.comstd::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left, 102913481Sgiacomo.travaglini@arm.com const std::vector<size_t>& right) { 103013481Sgiacomo.travaglini@arm.com std::vector<std::vector<double> > costs( 103113481Sgiacomo.travaglini@arm.com left.size() + 1, std::vector<double>(right.size() + 1)); 103213481Sgiacomo.travaglini@arm.com std::vector<std::vector<EditType> > best_move( 103313481Sgiacomo.travaglini@arm.com left.size() + 1, std::vector<EditType>(right.size() + 1)); 103413481Sgiacomo.travaglini@arm.com 103513481Sgiacomo.travaglini@arm.com // Populate for empty right. 103613481Sgiacomo.travaglini@arm.com for (size_t l_i = 0; l_i < costs.size(); ++l_i) { 103713481Sgiacomo.travaglini@arm.com costs[l_i][0] = static_cast<double>(l_i); 103813481Sgiacomo.travaglini@arm.com best_move[l_i][0] = kRemove; 103913481Sgiacomo.travaglini@arm.com } 104013481Sgiacomo.travaglini@arm.com // Populate for empty left. 104113481Sgiacomo.travaglini@arm.com for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) { 104213481Sgiacomo.travaglini@arm.com costs[0][r_i] = static_cast<double>(r_i); 104313481Sgiacomo.travaglini@arm.com best_move[0][r_i] = kAdd; 104413481Sgiacomo.travaglini@arm.com } 104513481Sgiacomo.travaglini@arm.com 104613481Sgiacomo.travaglini@arm.com for (size_t l_i = 0; l_i < left.size(); ++l_i) { 104713481Sgiacomo.travaglini@arm.com for (size_t r_i = 0; r_i < right.size(); ++r_i) { 104813481Sgiacomo.travaglini@arm.com if (left[l_i] == right[r_i]) { 104913481Sgiacomo.travaglini@arm.com // Found a match. Consume it. 105013481Sgiacomo.travaglini@arm.com costs[l_i + 1][r_i + 1] = costs[l_i][r_i]; 105113481Sgiacomo.travaglini@arm.com best_move[l_i + 1][r_i + 1] = kMatch; 105213481Sgiacomo.travaglini@arm.com continue; 105313481Sgiacomo.travaglini@arm.com } 105413481Sgiacomo.travaglini@arm.com 105513481Sgiacomo.travaglini@arm.com const double add = costs[l_i + 1][r_i]; 105613481Sgiacomo.travaglini@arm.com const double remove = costs[l_i][r_i + 1]; 105713481Sgiacomo.travaglini@arm.com const double replace = costs[l_i][r_i]; 105813481Sgiacomo.travaglini@arm.com if (add < remove && add < replace) { 105913481Sgiacomo.travaglini@arm.com costs[l_i + 1][r_i + 1] = add + 1; 106013481Sgiacomo.travaglini@arm.com best_move[l_i + 1][r_i + 1] = kAdd; 106113481Sgiacomo.travaglini@arm.com } else if (remove < add && remove < replace) { 106213481Sgiacomo.travaglini@arm.com costs[l_i + 1][r_i + 1] = remove + 1; 106313481Sgiacomo.travaglini@arm.com best_move[l_i + 1][r_i + 1] = kRemove; 106413481Sgiacomo.travaglini@arm.com } else { 106513481Sgiacomo.travaglini@arm.com // We make replace a little more expensive than add/remove to lower 106613481Sgiacomo.travaglini@arm.com // their priority. 106713481Sgiacomo.travaglini@arm.com costs[l_i + 1][r_i + 1] = replace + 1.00001; 106813481Sgiacomo.travaglini@arm.com best_move[l_i + 1][r_i + 1] = kReplace; 106913481Sgiacomo.travaglini@arm.com } 107013481Sgiacomo.travaglini@arm.com } 107113481Sgiacomo.travaglini@arm.com } 107213481Sgiacomo.travaglini@arm.com 107313481Sgiacomo.travaglini@arm.com // Reconstruct the best path. We do it in reverse order. 107413481Sgiacomo.travaglini@arm.com std::vector<EditType> best_path; 107513481Sgiacomo.travaglini@arm.com for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) { 107613481Sgiacomo.travaglini@arm.com EditType move = best_move[l_i][r_i]; 107713481Sgiacomo.travaglini@arm.com best_path.push_back(move); 107813481Sgiacomo.travaglini@arm.com l_i -= move != kAdd; 107913481Sgiacomo.travaglini@arm.com r_i -= move != kRemove; 108013481Sgiacomo.travaglini@arm.com } 108113481Sgiacomo.travaglini@arm.com std::reverse(best_path.begin(), best_path.end()); 108213481Sgiacomo.travaglini@arm.com return best_path; 108313481Sgiacomo.travaglini@arm.com} 108413481Sgiacomo.travaglini@arm.com 108513481Sgiacomo.travaglini@arm.comnamespace { 108613481Sgiacomo.travaglini@arm.com 108713481Sgiacomo.travaglini@arm.com// Helper class to convert string into ids with deduplication. 108813481Sgiacomo.travaglini@arm.comclass InternalStrings { 108913481Sgiacomo.travaglini@arm.com public: 109013481Sgiacomo.travaglini@arm.com size_t GetId(const std::string& str) { 109113481Sgiacomo.travaglini@arm.com IdMap::iterator it = ids_.find(str); 109213481Sgiacomo.travaglini@arm.com if (it != ids_.end()) return it->second; 109313481Sgiacomo.travaglini@arm.com size_t id = ids_.size(); 109413481Sgiacomo.travaglini@arm.com return ids_[str] = id; 109513481Sgiacomo.travaglini@arm.com } 109613481Sgiacomo.travaglini@arm.com 109713481Sgiacomo.travaglini@arm.com private: 109813481Sgiacomo.travaglini@arm.com typedef std::map<std::string, size_t> IdMap; 109913481Sgiacomo.travaglini@arm.com IdMap ids_; 110013481Sgiacomo.travaglini@arm.com}; 110113481Sgiacomo.travaglini@arm.com 110213481Sgiacomo.travaglini@arm.com} // namespace 110313481Sgiacomo.travaglini@arm.com 110413481Sgiacomo.travaglini@arm.comstd::vector<EditType> CalculateOptimalEdits( 110513481Sgiacomo.travaglini@arm.com const std::vector<std::string>& left, 110613481Sgiacomo.travaglini@arm.com const std::vector<std::string>& right) { 110713481Sgiacomo.travaglini@arm.com std::vector<size_t> left_ids, right_ids; 110813481Sgiacomo.travaglini@arm.com { 110913481Sgiacomo.travaglini@arm.com InternalStrings intern_table; 111013481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < left.size(); ++i) { 111113481Sgiacomo.travaglini@arm.com left_ids.push_back(intern_table.GetId(left[i])); 111213481Sgiacomo.travaglini@arm.com } 111313481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < right.size(); ++i) { 111413481Sgiacomo.travaglini@arm.com right_ids.push_back(intern_table.GetId(right[i])); 111513481Sgiacomo.travaglini@arm.com } 111613481Sgiacomo.travaglini@arm.com } 111713481Sgiacomo.travaglini@arm.com return CalculateOptimalEdits(left_ids, right_ids); 111813481Sgiacomo.travaglini@arm.com} 111913481Sgiacomo.travaglini@arm.com 112013481Sgiacomo.travaglini@arm.comnamespace { 112113481Sgiacomo.travaglini@arm.com 112213481Sgiacomo.travaglini@arm.com// Helper class that holds the state for one hunk and prints it out to the 112313481Sgiacomo.travaglini@arm.com// stream. 112413481Sgiacomo.travaglini@arm.com// It reorders adds/removes when possible to group all removes before all 112513481Sgiacomo.travaglini@arm.com// adds. It also adds the hunk header before printint into the stream. 112613481Sgiacomo.travaglini@arm.comclass Hunk { 112713481Sgiacomo.travaglini@arm.com public: 112813481Sgiacomo.travaglini@arm.com Hunk(size_t left_start, size_t right_start) 112913481Sgiacomo.travaglini@arm.com : left_start_(left_start), 113013481Sgiacomo.travaglini@arm.com right_start_(right_start), 113113481Sgiacomo.travaglini@arm.com adds_(), 113213481Sgiacomo.travaglini@arm.com removes_(), 113313481Sgiacomo.travaglini@arm.com common_() {} 113413481Sgiacomo.travaglini@arm.com 113513481Sgiacomo.travaglini@arm.com void PushLine(char edit, const char* line) { 113613481Sgiacomo.travaglini@arm.com switch (edit) { 113713481Sgiacomo.travaglini@arm.com case ' ': 113813481Sgiacomo.travaglini@arm.com ++common_; 113913481Sgiacomo.travaglini@arm.com FlushEdits(); 114013481Sgiacomo.travaglini@arm.com hunk_.push_back(std::make_pair(' ', line)); 114113481Sgiacomo.travaglini@arm.com break; 114213481Sgiacomo.travaglini@arm.com case '-': 114313481Sgiacomo.travaglini@arm.com ++removes_; 114413481Sgiacomo.travaglini@arm.com hunk_removes_.push_back(std::make_pair('-', line)); 114513481Sgiacomo.travaglini@arm.com break; 114613481Sgiacomo.travaglini@arm.com case '+': 114713481Sgiacomo.travaglini@arm.com ++adds_; 114813481Sgiacomo.travaglini@arm.com hunk_adds_.push_back(std::make_pair('+', line)); 114913481Sgiacomo.travaglini@arm.com break; 115013481Sgiacomo.travaglini@arm.com } 115113481Sgiacomo.travaglini@arm.com } 115213481Sgiacomo.travaglini@arm.com 115313481Sgiacomo.travaglini@arm.com void PrintTo(std::ostream* os) { 115413481Sgiacomo.travaglini@arm.com PrintHeader(os); 115513481Sgiacomo.travaglini@arm.com FlushEdits(); 115613481Sgiacomo.travaglini@arm.com for (std::list<std::pair<char, const char*> >::const_iterator it = 115713481Sgiacomo.travaglini@arm.com hunk_.begin(); 115813481Sgiacomo.travaglini@arm.com it != hunk_.end(); ++it) { 115913481Sgiacomo.travaglini@arm.com *os << it->first << it->second << "\n"; 116013481Sgiacomo.travaglini@arm.com } 116113481Sgiacomo.travaglini@arm.com } 116213481Sgiacomo.travaglini@arm.com 116313481Sgiacomo.travaglini@arm.com bool has_edits() const { return adds_ || removes_; } 116413481Sgiacomo.travaglini@arm.com 116513481Sgiacomo.travaglini@arm.com private: 116613481Sgiacomo.travaglini@arm.com void FlushEdits() { 116713481Sgiacomo.travaglini@arm.com hunk_.splice(hunk_.end(), hunk_removes_); 116813481Sgiacomo.travaglini@arm.com hunk_.splice(hunk_.end(), hunk_adds_); 116913481Sgiacomo.travaglini@arm.com } 117013481Sgiacomo.travaglini@arm.com 117113481Sgiacomo.travaglini@arm.com // Print a unified diff header for one hunk. 117213481Sgiacomo.travaglini@arm.com // The format is 117313481Sgiacomo.travaglini@arm.com // "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@" 117413481Sgiacomo.travaglini@arm.com // where the left/right parts are ommitted if unnecessary. 117513481Sgiacomo.travaglini@arm.com void PrintHeader(std::ostream* ss) const { 117613481Sgiacomo.travaglini@arm.com *ss << "@@ "; 117713481Sgiacomo.travaglini@arm.com if (removes_) { 117813481Sgiacomo.travaglini@arm.com *ss << "-" << left_start_ << "," << (removes_ + common_); 117913481Sgiacomo.travaglini@arm.com } 118013481Sgiacomo.travaglini@arm.com if (removes_ && adds_) { 118113481Sgiacomo.travaglini@arm.com *ss << " "; 118213481Sgiacomo.travaglini@arm.com } 118313481Sgiacomo.travaglini@arm.com if (adds_) { 118413481Sgiacomo.travaglini@arm.com *ss << "+" << right_start_ << "," << (adds_ + common_); 118513481Sgiacomo.travaglini@arm.com } 118613481Sgiacomo.travaglini@arm.com *ss << " @@\n"; 118713481Sgiacomo.travaglini@arm.com } 118813481Sgiacomo.travaglini@arm.com 118913481Sgiacomo.travaglini@arm.com size_t left_start_, right_start_; 119013481Sgiacomo.travaglini@arm.com size_t adds_, removes_, common_; 119113481Sgiacomo.travaglini@arm.com std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_; 119213481Sgiacomo.travaglini@arm.com}; 119313481Sgiacomo.travaglini@arm.com 119413481Sgiacomo.travaglini@arm.com} // namespace 119513481Sgiacomo.travaglini@arm.com 119613481Sgiacomo.travaglini@arm.com// Create a list of diff hunks in Unified diff format. 119713481Sgiacomo.travaglini@arm.com// Each hunk has a header generated by PrintHeader above plus a body with 119813481Sgiacomo.travaglini@arm.com// lines prefixed with ' ' for no change, '-' for deletion and '+' for 119913481Sgiacomo.travaglini@arm.com// addition. 120013481Sgiacomo.travaglini@arm.com// 'context' represents the desired unchanged prefix/suffix around the diff. 120113481Sgiacomo.travaglini@arm.com// If two hunks are close enough that their contexts overlap, then they are 120213481Sgiacomo.travaglini@arm.com// joined into one hunk. 120313481Sgiacomo.travaglini@arm.comstd::string CreateUnifiedDiff(const std::vector<std::string>& left, 120413481Sgiacomo.travaglini@arm.com const std::vector<std::string>& right, 120513481Sgiacomo.travaglini@arm.com size_t context) { 120613481Sgiacomo.travaglini@arm.com const std::vector<EditType> edits = CalculateOptimalEdits(left, right); 120713481Sgiacomo.travaglini@arm.com 120813481Sgiacomo.travaglini@arm.com size_t l_i = 0, r_i = 0, edit_i = 0; 120913481Sgiacomo.travaglini@arm.com std::stringstream ss; 121013481Sgiacomo.travaglini@arm.com while (edit_i < edits.size()) { 121113481Sgiacomo.travaglini@arm.com // Find first edit. 121213481Sgiacomo.travaglini@arm.com while (edit_i < edits.size() && edits[edit_i] == kMatch) { 121313481Sgiacomo.travaglini@arm.com ++l_i; 121413481Sgiacomo.travaglini@arm.com ++r_i; 121513481Sgiacomo.travaglini@arm.com ++edit_i; 121613481Sgiacomo.travaglini@arm.com } 121713481Sgiacomo.travaglini@arm.com 121813481Sgiacomo.travaglini@arm.com // Find the first line to include in the hunk. 121913481Sgiacomo.travaglini@arm.com const size_t prefix_context = std::min(l_i, context); 122013481Sgiacomo.travaglini@arm.com Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1); 122113481Sgiacomo.travaglini@arm.com for (size_t i = prefix_context; i > 0; --i) { 122213481Sgiacomo.travaglini@arm.com hunk.PushLine(' ', left[l_i - i].c_str()); 122313481Sgiacomo.travaglini@arm.com } 122413481Sgiacomo.travaglini@arm.com 122513481Sgiacomo.travaglini@arm.com // Iterate the edits until we found enough suffix for the hunk or the input 122613481Sgiacomo.travaglini@arm.com // is over. 122713481Sgiacomo.travaglini@arm.com size_t n_suffix = 0; 122813481Sgiacomo.travaglini@arm.com for (; edit_i < edits.size(); ++edit_i) { 122913481Sgiacomo.travaglini@arm.com if (n_suffix >= context) { 123013481Sgiacomo.travaglini@arm.com // Continue only if the next hunk is very close. 123113481Sgiacomo.travaglini@arm.com std::vector<EditType>::const_iterator it = edits.begin() + edit_i; 123213481Sgiacomo.travaglini@arm.com while (it != edits.end() && *it == kMatch) ++it; 123313481Sgiacomo.travaglini@arm.com if (it == edits.end() || (it - edits.begin()) - edit_i >= context) { 123413481Sgiacomo.travaglini@arm.com // There is no next edit or it is too far away. 123513481Sgiacomo.travaglini@arm.com break; 123613481Sgiacomo.travaglini@arm.com } 123713481Sgiacomo.travaglini@arm.com } 123813481Sgiacomo.travaglini@arm.com 123913481Sgiacomo.travaglini@arm.com EditType edit = edits[edit_i]; 124013481Sgiacomo.travaglini@arm.com // Reset count when a non match is found. 124113481Sgiacomo.travaglini@arm.com n_suffix = edit == kMatch ? n_suffix + 1 : 0; 124213481Sgiacomo.travaglini@arm.com 124313481Sgiacomo.travaglini@arm.com if (edit == kMatch || edit == kRemove || edit == kReplace) { 124413481Sgiacomo.travaglini@arm.com hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str()); 124513481Sgiacomo.travaglini@arm.com } 124613481Sgiacomo.travaglini@arm.com if (edit == kAdd || edit == kReplace) { 124713481Sgiacomo.travaglini@arm.com hunk.PushLine('+', right[r_i].c_str()); 124813481Sgiacomo.travaglini@arm.com } 124913481Sgiacomo.travaglini@arm.com 125013481Sgiacomo.travaglini@arm.com // Advance indices, depending on edit type. 125113481Sgiacomo.travaglini@arm.com l_i += edit != kAdd; 125213481Sgiacomo.travaglini@arm.com r_i += edit != kRemove; 125313481Sgiacomo.travaglini@arm.com } 125413481Sgiacomo.travaglini@arm.com 125513481Sgiacomo.travaglini@arm.com if (!hunk.has_edits()) { 125613481Sgiacomo.travaglini@arm.com // We are done. We don't want this hunk. 125713481Sgiacomo.travaglini@arm.com break; 125813481Sgiacomo.travaglini@arm.com } 125913481Sgiacomo.travaglini@arm.com 126013481Sgiacomo.travaglini@arm.com hunk.PrintTo(&ss); 126113481Sgiacomo.travaglini@arm.com } 126213481Sgiacomo.travaglini@arm.com return ss.str(); 126313481Sgiacomo.travaglini@arm.com} 126413481Sgiacomo.travaglini@arm.com 126513481Sgiacomo.travaglini@arm.com} // namespace edit_distance 126613481Sgiacomo.travaglini@arm.com 126713481Sgiacomo.travaglini@arm.comnamespace { 126813481Sgiacomo.travaglini@arm.com 126913481Sgiacomo.travaglini@arm.com// The string representation of the values received in EqFailure() are already 127013481Sgiacomo.travaglini@arm.com// escaped. Split them on escaped '\n' boundaries. Leave all other escaped 127113481Sgiacomo.travaglini@arm.com// characters the same. 127213481Sgiacomo.travaglini@arm.comstd::vector<std::string> SplitEscapedString(const std::string& str) { 127313481Sgiacomo.travaglini@arm.com std::vector<std::string> lines; 127413481Sgiacomo.travaglini@arm.com size_t start = 0, end = str.size(); 127513481Sgiacomo.travaglini@arm.com if (end > 2 && str[0] == '"' && str[end - 1] == '"') { 127613481Sgiacomo.travaglini@arm.com ++start; 127713481Sgiacomo.travaglini@arm.com --end; 127813481Sgiacomo.travaglini@arm.com } 127913481Sgiacomo.travaglini@arm.com bool escaped = false; 128013481Sgiacomo.travaglini@arm.com for (size_t i = start; i + 1 < end; ++i) { 128113481Sgiacomo.travaglini@arm.com if (escaped) { 128213481Sgiacomo.travaglini@arm.com escaped = false; 128313481Sgiacomo.travaglini@arm.com if (str[i] == 'n') { 128413481Sgiacomo.travaglini@arm.com lines.push_back(str.substr(start, i - start - 1)); 128513481Sgiacomo.travaglini@arm.com start = i + 1; 128613481Sgiacomo.travaglini@arm.com } 128713481Sgiacomo.travaglini@arm.com } else { 128813481Sgiacomo.travaglini@arm.com escaped = str[i] == '\\'; 128913481Sgiacomo.travaglini@arm.com } 129013481Sgiacomo.travaglini@arm.com } 129113481Sgiacomo.travaglini@arm.com lines.push_back(str.substr(start, end - start)); 129213481Sgiacomo.travaglini@arm.com return lines; 129313481Sgiacomo.travaglini@arm.com} 129413481Sgiacomo.travaglini@arm.com 129513481Sgiacomo.travaglini@arm.com} // namespace 129613481Sgiacomo.travaglini@arm.com 129713481Sgiacomo.travaglini@arm.com// Constructs and returns the message for an equality assertion 129813481Sgiacomo.travaglini@arm.com// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. 129913481Sgiacomo.travaglini@arm.com// 130013481Sgiacomo.travaglini@arm.com// The first four parameters are the expressions used in the assertion 130113481Sgiacomo.travaglini@arm.com// and their values, as strings. For example, for ASSERT_EQ(foo, bar) 130213481Sgiacomo.travaglini@arm.com// where foo is 5 and bar is 6, we have: 130313481Sgiacomo.travaglini@arm.com// 130413481Sgiacomo.travaglini@arm.com// lhs_expression: "foo" 130513481Sgiacomo.travaglini@arm.com// rhs_expression: "bar" 130613481Sgiacomo.travaglini@arm.com// lhs_value: "5" 130713481Sgiacomo.travaglini@arm.com// rhs_value: "6" 130813481Sgiacomo.travaglini@arm.com// 130913481Sgiacomo.travaglini@arm.com// The ignoring_case parameter is true iff the assertion is a 131013481Sgiacomo.travaglini@arm.com// *_STRCASEEQ*. When it's true, the string "Ignoring case" will 131113481Sgiacomo.travaglini@arm.com// be inserted into the message. 131213481Sgiacomo.travaglini@arm.comAssertionResult EqFailure(const char* lhs_expression, 131313481Sgiacomo.travaglini@arm.com const char* rhs_expression, 131413481Sgiacomo.travaglini@arm.com const std::string& lhs_value, 131513481Sgiacomo.travaglini@arm.com const std::string& rhs_value, 131613481Sgiacomo.travaglini@arm.com bool ignoring_case) { 131713481Sgiacomo.travaglini@arm.com Message msg; 131813481Sgiacomo.travaglini@arm.com msg << " Expected: " << lhs_expression; 131913481Sgiacomo.travaglini@arm.com if (lhs_value != lhs_expression) { 132013481Sgiacomo.travaglini@arm.com msg << "\n Which is: " << lhs_value; 132113481Sgiacomo.travaglini@arm.com } 132213481Sgiacomo.travaglini@arm.com msg << "\nTo be equal to: " << rhs_expression; 132313481Sgiacomo.travaglini@arm.com if (rhs_value != rhs_expression) { 132413481Sgiacomo.travaglini@arm.com msg << "\n Which is: " << rhs_value; 132513481Sgiacomo.travaglini@arm.com } 132613481Sgiacomo.travaglini@arm.com 132713481Sgiacomo.travaglini@arm.com if (ignoring_case) { 132813481Sgiacomo.travaglini@arm.com msg << "\nIgnoring case"; 132913481Sgiacomo.travaglini@arm.com } 133013481Sgiacomo.travaglini@arm.com 133113481Sgiacomo.travaglini@arm.com if (!lhs_value.empty() && !rhs_value.empty()) { 133213481Sgiacomo.travaglini@arm.com const std::vector<std::string> lhs_lines = 133313481Sgiacomo.travaglini@arm.com SplitEscapedString(lhs_value); 133413481Sgiacomo.travaglini@arm.com const std::vector<std::string> rhs_lines = 133513481Sgiacomo.travaglini@arm.com SplitEscapedString(rhs_value); 133613481Sgiacomo.travaglini@arm.com if (lhs_lines.size() > 1 || rhs_lines.size() > 1) { 133713481Sgiacomo.travaglini@arm.com msg << "\nWith diff:\n" 133813481Sgiacomo.travaglini@arm.com << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines); 133913481Sgiacomo.travaglini@arm.com } 134013481Sgiacomo.travaglini@arm.com } 134113481Sgiacomo.travaglini@arm.com 134213481Sgiacomo.travaglini@arm.com return AssertionFailure() << msg; 134313481Sgiacomo.travaglini@arm.com} 134413481Sgiacomo.travaglini@arm.com 134513481Sgiacomo.travaglini@arm.com// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. 134613481Sgiacomo.travaglini@arm.comstd::string GetBoolAssertionFailureMessage( 134713481Sgiacomo.travaglini@arm.com const AssertionResult& assertion_result, 134813481Sgiacomo.travaglini@arm.com const char* expression_text, 134913481Sgiacomo.travaglini@arm.com const char* actual_predicate_value, 135013481Sgiacomo.travaglini@arm.com const char* expected_predicate_value) { 135113481Sgiacomo.travaglini@arm.com const char* actual_message = assertion_result.message(); 135213481Sgiacomo.travaglini@arm.com Message msg; 135313481Sgiacomo.travaglini@arm.com msg << "Value of: " << expression_text 135413481Sgiacomo.travaglini@arm.com << "\n Actual: " << actual_predicate_value; 135513481Sgiacomo.travaglini@arm.com if (actual_message[0] != '\0') 135613481Sgiacomo.travaglini@arm.com msg << " (" << actual_message << ")"; 135713481Sgiacomo.travaglini@arm.com msg << "\nExpected: " << expected_predicate_value; 135813481Sgiacomo.travaglini@arm.com return msg.GetString(); 135913481Sgiacomo.travaglini@arm.com} 136013481Sgiacomo.travaglini@arm.com 136113481Sgiacomo.travaglini@arm.com// Helper function for implementing ASSERT_NEAR. 136213481Sgiacomo.travaglini@arm.comAssertionResult DoubleNearPredFormat(const char* expr1, 136313481Sgiacomo.travaglini@arm.com const char* expr2, 136413481Sgiacomo.travaglini@arm.com const char* abs_error_expr, 136513481Sgiacomo.travaglini@arm.com double val1, 136613481Sgiacomo.travaglini@arm.com double val2, 136713481Sgiacomo.travaglini@arm.com double abs_error) { 136813481Sgiacomo.travaglini@arm.com const double diff = fabs(val1 - val2); 136913481Sgiacomo.travaglini@arm.com if (diff <= abs_error) return AssertionSuccess(); 137013481Sgiacomo.travaglini@arm.com 137113481Sgiacomo.travaglini@arm.com // TODO(wan): do not print the value of an expression if it's 137213481Sgiacomo.travaglini@arm.com // already a literal. 137313481Sgiacomo.travaglini@arm.com return AssertionFailure() 137413481Sgiacomo.travaglini@arm.com << "The difference between " << expr1 << " and " << expr2 137513481Sgiacomo.travaglini@arm.com << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" 137613481Sgiacomo.travaglini@arm.com << expr1 << " evaluates to " << val1 << ",\n" 137713481Sgiacomo.travaglini@arm.com << expr2 << " evaluates to " << val2 << ", and\n" 137813481Sgiacomo.travaglini@arm.com << abs_error_expr << " evaluates to " << abs_error << "."; 137913481Sgiacomo.travaglini@arm.com} 138013481Sgiacomo.travaglini@arm.com 138113481Sgiacomo.travaglini@arm.com 138213481Sgiacomo.travaglini@arm.com// Helper template for implementing FloatLE() and DoubleLE(). 138313481Sgiacomo.travaglini@arm.comtemplate <typename RawType> 138413481Sgiacomo.travaglini@arm.comAssertionResult FloatingPointLE(const char* expr1, 138513481Sgiacomo.travaglini@arm.com const char* expr2, 138613481Sgiacomo.travaglini@arm.com RawType val1, 138713481Sgiacomo.travaglini@arm.com RawType val2) { 138813481Sgiacomo.travaglini@arm.com // Returns success if val1 is less than val2, 138913481Sgiacomo.travaglini@arm.com if (val1 < val2) { 139013481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 139113481Sgiacomo.travaglini@arm.com } 139213481Sgiacomo.travaglini@arm.com 139313481Sgiacomo.travaglini@arm.com // or if val1 is almost equal to val2. 139413481Sgiacomo.travaglini@arm.com const FloatingPoint<RawType> lhs(val1), rhs(val2); 139513481Sgiacomo.travaglini@arm.com if (lhs.AlmostEquals(rhs)) { 139613481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 139713481Sgiacomo.travaglini@arm.com } 139813481Sgiacomo.travaglini@arm.com 139913481Sgiacomo.travaglini@arm.com // Note that the above two checks will both fail if either val1 or 140013481Sgiacomo.travaglini@arm.com // val2 is NaN, as the IEEE floating-point standard requires that 140113481Sgiacomo.travaglini@arm.com // any predicate involving a NaN must return false. 140213481Sgiacomo.travaglini@arm.com 140313481Sgiacomo.travaglini@arm.com ::std::stringstream val1_ss; 140413481Sgiacomo.travaglini@arm.com val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 140513481Sgiacomo.travaglini@arm.com << val1; 140613481Sgiacomo.travaglini@arm.com 140713481Sgiacomo.travaglini@arm.com ::std::stringstream val2_ss; 140813481Sgiacomo.travaglini@arm.com val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 140913481Sgiacomo.travaglini@arm.com << val2; 141013481Sgiacomo.travaglini@arm.com 141113481Sgiacomo.travaglini@arm.com return AssertionFailure() 141213481Sgiacomo.travaglini@arm.com << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" 141313481Sgiacomo.travaglini@arm.com << " Actual: " << StringStreamToString(&val1_ss) << " vs " 141413481Sgiacomo.travaglini@arm.com << StringStreamToString(&val2_ss); 141513481Sgiacomo.travaglini@arm.com} 141613481Sgiacomo.travaglini@arm.com 141713481Sgiacomo.travaglini@arm.com} // namespace internal 141813481Sgiacomo.travaglini@arm.com 141913481Sgiacomo.travaglini@arm.com// Asserts that val1 is less than, or almost equal to, val2. Fails 142013481Sgiacomo.travaglini@arm.com// otherwise. In particular, it fails if either val1 or val2 is NaN. 142113481Sgiacomo.travaglini@arm.comAssertionResult FloatLE(const char* expr1, const char* expr2, 142213481Sgiacomo.travaglini@arm.com float val1, float val2) { 142313481Sgiacomo.travaglini@arm.com return internal::FloatingPointLE<float>(expr1, expr2, val1, val2); 142413481Sgiacomo.travaglini@arm.com} 142513481Sgiacomo.travaglini@arm.com 142613481Sgiacomo.travaglini@arm.com// Asserts that val1 is less than, or almost equal to, val2. Fails 142713481Sgiacomo.travaglini@arm.com// otherwise. In particular, it fails if either val1 or val2 is NaN. 142813481Sgiacomo.travaglini@arm.comAssertionResult DoubleLE(const char* expr1, const char* expr2, 142913481Sgiacomo.travaglini@arm.com double val1, double val2) { 143013481Sgiacomo.travaglini@arm.com return internal::FloatingPointLE<double>(expr1, expr2, val1, val2); 143113481Sgiacomo.travaglini@arm.com} 143213481Sgiacomo.travaglini@arm.com 143313481Sgiacomo.travaglini@arm.comnamespace internal { 143413481Sgiacomo.travaglini@arm.com 143513481Sgiacomo.travaglini@arm.com// The helper function for {ASSERT|EXPECT}_EQ with int or enum 143613481Sgiacomo.travaglini@arm.com// arguments. 143713481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperEQ(const char* lhs_expression, 143813481Sgiacomo.travaglini@arm.com const char* rhs_expression, 143913481Sgiacomo.travaglini@arm.com BiggestInt lhs, 144013481Sgiacomo.travaglini@arm.com BiggestInt rhs) { 144113481Sgiacomo.travaglini@arm.com if (lhs == rhs) { 144213481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 144313481Sgiacomo.travaglini@arm.com } 144413481Sgiacomo.travaglini@arm.com 144513481Sgiacomo.travaglini@arm.com return EqFailure(lhs_expression, 144613481Sgiacomo.travaglini@arm.com rhs_expression, 144713481Sgiacomo.travaglini@arm.com FormatForComparisonFailureMessage(lhs, rhs), 144813481Sgiacomo.travaglini@arm.com FormatForComparisonFailureMessage(rhs, lhs), 144913481Sgiacomo.travaglini@arm.com false); 145013481Sgiacomo.travaglini@arm.com} 145113481Sgiacomo.travaglini@arm.com 145213481Sgiacomo.travaglini@arm.com// A macro for implementing the helper functions needed to implement 145313481Sgiacomo.travaglini@arm.com// ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here 145413481Sgiacomo.travaglini@arm.com// just to avoid copy-and-paste of similar code. 145513481Sgiacomo.travaglini@arm.com#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ 145613481Sgiacomo.travaglini@arm.comAssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ 145713481Sgiacomo.travaglini@arm.com BiggestInt val1, BiggestInt val2) {\ 145813481Sgiacomo.travaglini@arm.com if (val1 op val2) {\ 145913481Sgiacomo.travaglini@arm.com return AssertionSuccess();\ 146013481Sgiacomo.travaglini@arm.com } else {\ 146113481Sgiacomo.travaglini@arm.com return AssertionFailure() \ 146213481Sgiacomo.travaglini@arm.com << "Expected: (" << expr1 << ") " #op " (" << expr2\ 146313481Sgiacomo.travaglini@arm.com << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ 146413481Sgiacomo.travaglini@arm.com << " vs " << FormatForComparisonFailureMessage(val2, val1);\ 146513481Sgiacomo.travaglini@arm.com }\ 146613481Sgiacomo.travaglini@arm.com} 146713481Sgiacomo.travaglini@arm.com 146813481Sgiacomo.travaglini@arm.com// Implements the helper function for {ASSERT|EXPECT}_NE with int or 146913481Sgiacomo.travaglini@arm.com// enum arguments. 147013481Sgiacomo.travaglini@arm.comGTEST_IMPL_CMP_HELPER_(NE, !=) 147113481Sgiacomo.travaglini@arm.com// Implements the helper function for {ASSERT|EXPECT}_LE with int or 147213481Sgiacomo.travaglini@arm.com// enum arguments. 147313481Sgiacomo.travaglini@arm.comGTEST_IMPL_CMP_HELPER_(LE, <=) 147413481Sgiacomo.travaglini@arm.com// Implements the helper function for {ASSERT|EXPECT}_LT with int or 147513481Sgiacomo.travaglini@arm.com// enum arguments. 147613481Sgiacomo.travaglini@arm.comGTEST_IMPL_CMP_HELPER_(LT, < ) 147713481Sgiacomo.travaglini@arm.com// Implements the helper function for {ASSERT|EXPECT}_GE with int or 147813481Sgiacomo.travaglini@arm.com// enum arguments. 147913481Sgiacomo.travaglini@arm.comGTEST_IMPL_CMP_HELPER_(GE, >=) 148013481Sgiacomo.travaglini@arm.com// Implements the helper function for {ASSERT|EXPECT}_GT with int or 148113481Sgiacomo.travaglini@arm.com// enum arguments. 148213481Sgiacomo.travaglini@arm.comGTEST_IMPL_CMP_HELPER_(GT, > ) 148313481Sgiacomo.travaglini@arm.com 148413481Sgiacomo.travaglini@arm.com#undef GTEST_IMPL_CMP_HELPER_ 148513481Sgiacomo.travaglini@arm.com 148613481Sgiacomo.travaglini@arm.com// The helper function for {ASSERT|EXPECT}_STREQ. 148713481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperSTREQ(const char* lhs_expression, 148813481Sgiacomo.travaglini@arm.com const char* rhs_expression, 148913481Sgiacomo.travaglini@arm.com const char* lhs, 149013481Sgiacomo.travaglini@arm.com const char* rhs) { 149113481Sgiacomo.travaglini@arm.com if (String::CStringEquals(lhs, rhs)) { 149213481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 149313481Sgiacomo.travaglini@arm.com } 149413481Sgiacomo.travaglini@arm.com 149513481Sgiacomo.travaglini@arm.com return EqFailure(lhs_expression, 149613481Sgiacomo.travaglini@arm.com rhs_expression, 149713481Sgiacomo.travaglini@arm.com PrintToString(lhs), 149813481Sgiacomo.travaglini@arm.com PrintToString(rhs), 149913481Sgiacomo.travaglini@arm.com false); 150013481Sgiacomo.travaglini@arm.com} 150113481Sgiacomo.travaglini@arm.com 150213481Sgiacomo.travaglini@arm.com// The helper function for {ASSERT|EXPECT}_STRCASEEQ. 150313481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression, 150413481Sgiacomo.travaglini@arm.com const char* rhs_expression, 150513481Sgiacomo.travaglini@arm.com const char* lhs, 150613481Sgiacomo.travaglini@arm.com const char* rhs) { 150713481Sgiacomo.travaglini@arm.com if (String::CaseInsensitiveCStringEquals(lhs, rhs)) { 150813481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 150913481Sgiacomo.travaglini@arm.com } 151013481Sgiacomo.travaglini@arm.com 151113481Sgiacomo.travaglini@arm.com return EqFailure(lhs_expression, 151213481Sgiacomo.travaglini@arm.com rhs_expression, 151313481Sgiacomo.travaglini@arm.com PrintToString(lhs), 151413481Sgiacomo.travaglini@arm.com PrintToString(rhs), 151513481Sgiacomo.travaglini@arm.com true); 151613481Sgiacomo.travaglini@arm.com} 151713481Sgiacomo.travaglini@arm.com 151813481Sgiacomo.travaglini@arm.com// The helper function for {ASSERT|EXPECT}_STRNE. 151913481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperSTRNE(const char* s1_expression, 152013481Sgiacomo.travaglini@arm.com const char* s2_expression, 152113481Sgiacomo.travaglini@arm.com const char* s1, 152213481Sgiacomo.travaglini@arm.com const char* s2) { 152313481Sgiacomo.travaglini@arm.com if (!String::CStringEquals(s1, s2)) { 152413481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 152513481Sgiacomo.travaglini@arm.com } else { 152613481Sgiacomo.travaglini@arm.com return AssertionFailure() << "Expected: (" << s1_expression << ") != (" 152713481Sgiacomo.travaglini@arm.com << s2_expression << "), actual: \"" 152813481Sgiacomo.travaglini@arm.com << s1 << "\" vs \"" << s2 << "\""; 152913481Sgiacomo.travaglini@arm.com } 153013481Sgiacomo.travaglini@arm.com} 153113481Sgiacomo.travaglini@arm.com 153213481Sgiacomo.travaglini@arm.com// The helper function for {ASSERT|EXPECT}_STRCASENE. 153313481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperSTRCASENE(const char* s1_expression, 153413481Sgiacomo.travaglini@arm.com const char* s2_expression, 153513481Sgiacomo.travaglini@arm.com const char* s1, 153613481Sgiacomo.travaglini@arm.com const char* s2) { 153713481Sgiacomo.travaglini@arm.com if (!String::CaseInsensitiveCStringEquals(s1, s2)) { 153813481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 153913481Sgiacomo.travaglini@arm.com } else { 154013481Sgiacomo.travaglini@arm.com return AssertionFailure() 154113481Sgiacomo.travaglini@arm.com << "Expected: (" << s1_expression << ") != (" 154213481Sgiacomo.travaglini@arm.com << s2_expression << ") (ignoring case), actual: \"" 154313481Sgiacomo.travaglini@arm.com << s1 << "\" vs \"" << s2 << "\""; 154413481Sgiacomo.travaglini@arm.com } 154513481Sgiacomo.travaglini@arm.com} 154613481Sgiacomo.travaglini@arm.com 154713481Sgiacomo.travaglini@arm.com} // namespace internal 154813481Sgiacomo.travaglini@arm.com 154913481Sgiacomo.travaglini@arm.comnamespace { 155013481Sgiacomo.travaglini@arm.com 155113481Sgiacomo.travaglini@arm.com// Helper functions for implementing IsSubString() and IsNotSubstring(). 155213481Sgiacomo.travaglini@arm.com 155313481Sgiacomo.travaglini@arm.com// This group of overloaded functions return true iff needle is a 155413481Sgiacomo.travaglini@arm.com// substring of haystack. NULL is considered a substring of itself 155513481Sgiacomo.travaglini@arm.com// only. 155613481Sgiacomo.travaglini@arm.com 155713481Sgiacomo.travaglini@arm.combool IsSubstringPred(const char* needle, const char* haystack) { 155813481Sgiacomo.travaglini@arm.com if (needle == NULL || haystack == NULL) 155913481Sgiacomo.travaglini@arm.com return needle == haystack; 156013481Sgiacomo.travaglini@arm.com 156113481Sgiacomo.travaglini@arm.com return strstr(haystack, needle) != NULL; 156213481Sgiacomo.travaglini@arm.com} 156313481Sgiacomo.travaglini@arm.com 156413481Sgiacomo.travaglini@arm.combool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { 156513481Sgiacomo.travaglini@arm.com if (needle == NULL || haystack == NULL) 156613481Sgiacomo.travaglini@arm.com return needle == haystack; 156713481Sgiacomo.travaglini@arm.com 156813481Sgiacomo.travaglini@arm.com return wcsstr(haystack, needle) != NULL; 156913481Sgiacomo.travaglini@arm.com} 157013481Sgiacomo.travaglini@arm.com 157113481Sgiacomo.travaglini@arm.com// StringType here can be either ::std::string or ::std::wstring. 157213481Sgiacomo.travaglini@arm.comtemplate <typename StringType> 157313481Sgiacomo.travaglini@arm.combool IsSubstringPred(const StringType& needle, 157413481Sgiacomo.travaglini@arm.com const StringType& haystack) { 157513481Sgiacomo.travaglini@arm.com return haystack.find(needle) != StringType::npos; 157613481Sgiacomo.travaglini@arm.com} 157713481Sgiacomo.travaglini@arm.com 157813481Sgiacomo.travaglini@arm.com// This function implements either IsSubstring() or IsNotSubstring(), 157913481Sgiacomo.travaglini@arm.com// depending on the value of the expected_to_be_substring parameter. 158013481Sgiacomo.travaglini@arm.com// StringType here can be const char*, const wchar_t*, ::std::string, 158113481Sgiacomo.travaglini@arm.com// or ::std::wstring. 158213481Sgiacomo.travaglini@arm.comtemplate <typename StringType> 158313481Sgiacomo.travaglini@arm.comAssertionResult IsSubstringImpl( 158413481Sgiacomo.travaglini@arm.com bool expected_to_be_substring, 158513481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 158613481Sgiacomo.travaglini@arm.com const StringType& needle, const StringType& haystack) { 158713481Sgiacomo.travaglini@arm.com if (IsSubstringPred(needle, haystack) == expected_to_be_substring) 158813481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 158913481Sgiacomo.travaglini@arm.com 159013481Sgiacomo.travaglini@arm.com const bool is_wide_string = sizeof(needle[0]) > 1; 159113481Sgiacomo.travaglini@arm.com const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; 159213481Sgiacomo.travaglini@arm.com return AssertionFailure() 159313481Sgiacomo.travaglini@arm.com << "Value of: " << needle_expr << "\n" 159413481Sgiacomo.travaglini@arm.com << " Actual: " << begin_string_quote << needle << "\"\n" 159513481Sgiacomo.travaglini@arm.com << "Expected: " << (expected_to_be_substring ? "" : "not ") 159613481Sgiacomo.travaglini@arm.com << "a substring of " << haystack_expr << "\n" 159713481Sgiacomo.travaglini@arm.com << "Which is: " << begin_string_quote << haystack << "\""; 159813481Sgiacomo.travaglini@arm.com} 159913481Sgiacomo.travaglini@arm.com 160013481Sgiacomo.travaglini@arm.com} // namespace 160113481Sgiacomo.travaglini@arm.com 160213481Sgiacomo.travaglini@arm.com// IsSubstring() and IsNotSubstring() check whether needle is a 160313481Sgiacomo.travaglini@arm.com// substring of haystack (NULL is considered a substring of itself 160413481Sgiacomo.travaglini@arm.com// only), and return an appropriate error message when they fail. 160513481Sgiacomo.travaglini@arm.com 160613481Sgiacomo.travaglini@arm.comAssertionResult IsSubstring( 160713481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 160813481Sgiacomo.travaglini@arm.com const char* needle, const char* haystack) { 160913481Sgiacomo.travaglini@arm.com return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 161013481Sgiacomo.travaglini@arm.com} 161113481Sgiacomo.travaglini@arm.com 161213481Sgiacomo.travaglini@arm.comAssertionResult IsSubstring( 161313481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 161413481Sgiacomo.travaglini@arm.com const wchar_t* needle, const wchar_t* haystack) { 161513481Sgiacomo.travaglini@arm.com return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 161613481Sgiacomo.travaglini@arm.com} 161713481Sgiacomo.travaglini@arm.com 161813481Sgiacomo.travaglini@arm.comAssertionResult IsNotSubstring( 161913481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 162013481Sgiacomo.travaglini@arm.com const char* needle, const char* haystack) { 162113481Sgiacomo.travaglini@arm.com return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 162213481Sgiacomo.travaglini@arm.com} 162313481Sgiacomo.travaglini@arm.com 162413481Sgiacomo.travaglini@arm.comAssertionResult IsNotSubstring( 162513481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 162613481Sgiacomo.travaglini@arm.com const wchar_t* needle, const wchar_t* haystack) { 162713481Sgiacomo.travaglini@arm.com return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 162813481Sgiacomo.travaglini@arm.com} 162913481Sgiacomo.travaglini@arm.com 163013481Sgiacomo.travaglini@arm.comAssertionResult IsSubstring( 163113481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 163213481Sgiacomo.travaglini@arm.com const ::std::string& needle, const ::std::string& haystack) { 163313481Sgiacomo.travaglini@arm.com return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 163413481Sgiacomo.travaglini@arm.com} 163513481Sgiacomo.travaglini@arm.com 163613481Sgiacomo.travaglini@arm.comAssertionResult IsNotSubstring( 163713481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 163813481Sgiacomo.travaglini@arm.com const ::std::string& needle, const ::std::string& haystack) { 163913481Sgiacomo.travaglini@arm.com return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 164013481Sgiacomo.travaglini@arm.com} 164113481Sgiacomo.travaglini@arm.com 164213481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_WSTRING 164313481Sgiacomo.travaglini@arm.comAssertionResult IsSubstring( 164413481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 164513481Sgiacomo.travaglini@arm.com const ::std::wstring& needle, const ::std::wstring& haystack) { 164613481Sgiacomo.travaglini@arm.com return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); 164713481Sgiacomo.travaglini@arm.com} 164813481Sgiacomo.travaglini@arm.com 164913481Sgiacomo.travaglini@arm.comAssertionResult IsNotSubstring( 165013481Sgiacomo.travaglini@arm.com const char* needle_expr, const char* haystack_expr, 165113481Sgiacomo.travaglini@arm.com const ::std::wstring& needle, const ::std::wstring& haystack) { 165213481Sgiacomo.travaglini@arm.com return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); 165313481Sgiacomo.travaglini@arm.com} 165413481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STD_WSTRING 165513481Sgiacomo.travaglini@arm.com 165613481Sgiacomo.travaglini@arm.comnamespace internal { 165713481Sgiacomo.travaglini@arm.com 165813481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 165913481Sgiacomo.travaglini@arm.com 166013481Sgiacomo.travaglini@arm.comnamespace { 166113481Sgiacomo.travaglini@arm.com 166213481Sgiacomo.travaglini@arm.com// Helper function for IsHRESULT{SuccessFailure} predicates 166313481Sgiacomo.travaglini@arm.comAssertionResult HRESULTFailureHelper(const char* expr, 166413481Sgiacomo.travaglini@arm.com const char* expected, 166513481Sgiacomo.travaglini@arm.com long hr) { // NOLINT 166613481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MOBILE 166713481Sgiacomo.travaglini@arm.com 166813481Sgiacomo.travaglini@arm.com // Windows CE doesn't support FormatMessage. 166913481Sgiacomo.travaglini@arm.com const char error_text[] = ""; 167013481Sgiacomo.travaglini@arm.com 167113481Sgiacomo.travaglini@arm.com# else 167213481Sgiacomo.travaglini@arm.com 167313481Sgiacomo.travaglini@arm.com // Looks up the human-readable system message for the HRESULT code 167413481Sgiacomo.travaglini@arm.com // and since we're not passing any params to FormatMessage, we don't 167513481Sgiacomo.travaglini@arm.com // want inserts expanded. 167613481Sgiacomo.travaglini@arm.com const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | 167713481Sgiacomo.travaglini@arm.com FORMAT_MESSAGE_IGNORE_INSERTS; 167813481Sgiacomo.travaglini@arm.com const DWORD kBufSize = 4096; 167913481Sgiacomo.travaglini@arm.com // Gets the system's human readable message string for this HRESULT. 168013481Sgiacomo.travaglini@arm.com char error_text[kBufSize] = { '\0' }; 168113481Sgiacomo.travaglini@arm.com DWORD message_length = ::FormatMessageA(kFlags, 168213481Sgiacomo.travaglini@arm.com 0, // no source, we're asking system 168313481Sgiacomo.travaglini@arm.com hr, // the error 168413481Sgiacomo.travaglini@arm.com 0, // no line width restrictions 168513481Sgiacomo.travaglini@arm.com error_text, // output buffer 168613481Sgiacomo.travaglini@arm.com kBufSize, // buf size 168713481Sgiacomo.travaglini@arm.com NULL); // no arguments for inserts 168813481Sgiacomo.travaglini@arm.com // Trims tailing white space (FormatMessage leaves a trailing CR-LF) 168913481Sgiacomo.travaglini@arm.com for (; message_length && IsSpace(error_text[message_length - 1]); 169013481Sgiacomo.travaglini@arm.com --message_length) { 169113481Sgiacomo.travaglini@arm.com error_text[message_length - 1] = '\0'; 169213481Sgiacomo.travaglini@arm.com } 169313481Sgiacomo.travaglini@arm.com 169413481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS_MOBILE 169513481Sgiacomo.travaglini@arm.com 169613481Sgiacomo.travaglini@arm.com const std::string error_hex("0x" + String::FormatHexInt(hr)); 169713481Sgiacomo.travaglini@arm.com return ::testing::AssertionFailure() 169813481Sgiacomo.travaglini@arm.com << "Expected: " << expr << " " << expected << ".\n" 169913481Sgiacomo.travaglini@arm.com << " Actual: " << error_hex << " " << error_text << "\n"; 170013481Sgiacomo.travaglini@arm.com} 170113481Sgiacomo.travaglini@arm.com 170213481Sgiacomo.travaglini@arm.com} // namespace 170313481Sgiacomo.travaglini@arm.com 170413481Sgiacomo.travaglini@arm.comAssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT 170513481Sgiacomo.travaglini@arm.com if (SUCCEEDED(hr)) { 170613481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 170713481Sgiacomo.travaglini@arm.com } 170813481Sgiacomo.travaglini@arm.com return HRESULTFailureHelper(expr, "succeeds", hr); 170913481Sgiacomo.travaglini@arm.com} 171013481Sgiacomo.travaglini@arm.com 171113481Sgiacomo.travaglini@arm.comAssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT 171213481Sgiacomo.travaglini@arm.com if (FAILED(hr)) { 171313481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 171413481Sgiacomo.travaglini@arm.com } 171513481Sgiacomo.travaglini@arm.com return HRESULTFailureHelper(expr, "fails", hr); 171613481Sgiacomo.travaglini@arm.com} 171713481Sgiacomo.travaglini@arm.com 171813481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 171913481Sgiacomo.travaglini@arm.com 172013481Sgiacomo.travaglini@arm.com// Utility functions for encoding Unicode text (wide strings) in 172113481Sgiacomo.travaglini@arm.com// UTF-8. 172213481Sgiacomo.travaglini@arm.com 172313481Sgiacomo.travaglini@arm.com// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 172413481Sgiacomo.travaglini@arm.com// like this: 172513481Sgiacomo.travaglini@arm.com// 172613481Sgiacomo.travaglini@arm.com// Code-point length Encoding 172713481Sgiacomo.travaglini@arm.com// 0 - 7 bits 0xxxxxxx 172813481Sgiacomo.travaglini@arm.com// 8 - 11 bits 110xxxxx 10xxxxxx 172913481Sgiacomo.travaglini@arm.com// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx 173013481Sgiacomo.travaglini@arm.com// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 173113481Sgiacomo.travaglini@arm.com 173213481Sgiacomo.travaglini@arm.com// The maximum code-point a one-byte UTF-8 sequence can represent. 173313481Sgiacomo.travaglini@arm.comconst UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1; 173413481Sgiacomo.travaglini@arm.com 173513481Sgiacomo.travaglini@arm.com// The maximum code-point a two-byte UTF-8 sequence can represent. 173613481Sgiacomo.travaglini@arm.comconst UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1; 173713481Sgiacomo.travaglini@arm.com 173813481Sgiacomo.travaglini@arm.com// The maximum code-point a three-byte UTF-8 sequence can represent. 173913481Sgiacomo.travaglini@arm.comconst UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1; 174013481Sgiacomo.travaglini@arm.com 174113481Sgiacomo.travaglini@arm.com// The maximum code-point a four-byte UTF-8 sequence can represent. 174213481Sgiacomo.travaglini@arm.comconst UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1; 174313481Sgiacomo.travaglini@arm.com 174413481Sgiacomo.travaglini@arm.com// Chops off the n lowest bits from a bit pattern. Returns the n 174513481Sgiacomo.travaglini@arm.com// lowest bits. As a side effect, the original bit pattern will be 174613481Sgiacomo.travaglini@arm.com// shifted to the right by n bits. 174713481Sgiacomo.travaglini@arm.cominline UInt32 ChopLowBits(UInt32* bits, int n) { 174813481Sgiacomo.travaglini@arm.com const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1); 174913481Sgiacomo.travaglini@arm.com *bits >>= n; 175013481Sgiacomo.travaglini@arm.com return low_bits; 175113481Sgiacomo.travaglini@arm.com} 175213481Sgiacomo.travaglini@arm.com 175313481Sgiacomo.travaglini@arm.com// Converts a Unicode code point to a narrow string in UTF-8 encoding. 175413481Sgiacomo.travaglini@arm.com// code_point parameter is of type UInt32 because wchar_t may not be 175513481Sgiacomo.travaglini@arm.com// wide enough to contain a code point. 175613481Sgiacomo.travaglini@arm.com// If the code_point is not a valid Unicode code point 175713481Sgiacomo.travaglini@arm.com// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted 175813481Sgiacomo.travaglini@arm.com// to "(Invalid Unicode 0xXXXXXXXX)". 175913481Sgiacomo.travaglini@arm.comstd::string CodePointToUtf8(UInt32 code_point) { 176013481Sgiacomo.travaglini@arm.com if (code_point > kMaxCodePoint4) { 176113481Sgiacomo.travaglini@arm.com return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")"; 176213481Sgiacomo.travaglini@arm.com } 176313481Sgiacomo.travaglini@arm.com 176413481Sgiacomo.travaglini@arm.com char str[5]; // Big enough for the largest valid code point. 176513481Sgiacomo.travaglini@arm.com if (code_point <= kMaxCodePoint1) { 176613481Sgiacomo.travaglini@arm.com str[1] = '\0'; 176713481Sgiacomo.travaglini@arm.com str[0] = static_cast<char>(code_point); // 0xxxxxxx 176813481Sgiacomo.travaglini@arm.com } else if (code_point <= kMaxCodePoint2) { 176913481Sgiacomo.travaglini@arm.com str[2] = '\0'; 177013481Sgiacomo.travaglini@arm.com str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 177113481Sgiacomo.travaglini@arm.com str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx 177213481Sgiacomo.travaglini@arm.com } else if (code_point <= kMaxCodePoint3) { 177313481Sgiacomo.travaglini@arm.com str[3] = '\0'; 177413481Sgiacomo.travaglini@arm.com str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 177513481Sgiacomo.travaglini@arm.com str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 177613481Sgiacomo.travaglini@arm.com str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx 177713481Sgiacomo.travaglini@arm.com } else { // code_point <= kMaxCodePoint4 177813481Sgiacomo.travaglini@arm.com str[4] = '\0'; 177913481Sgiacomo.travaglini@arm.com str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 178013481Sgiacomo.travaglini@arm.com str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 178113481Sgiacomo.travaglini@arm.com str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx 178213481Sgiacomo.travaglini@arm.com str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx 178313481Sgiacomo.travaglini@arm.com } 178413481Sgiacomo.travaglini@arm.com return str; 178513481Sgiacomo.travaglini@arm.com} 178613481Sgiacomo.travaglini@arm.com 178713481Sgiacomo.travaglini@arm.com// The following two functions only make sense if the the system 178813481Sgiacomo.travaglini@arm.com// uses UTF-16 for wide string encoding. All supported systems 178913481Sgiacomo.travaglini@arm.com// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. 179013481Sgiacomo.travaglini@arm.com 179113481Sgiacomo.travaglini@arm.com// Determines if the arguments constitute UTF-16 surrogate pair 179213481Sgiacomo.travaglini@arm.com// and thus should be combined into a single Unicode code point 179313481Sgiacomo.travaglini@arm.com// using CreateCodePointFromUtf16SurrogatePair. 179413481Sgiacomo.travaglini@arm.cominline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { 179513481Sgiacomo.travaglini@arm.com return sizeof(wchar_t) == 2 && 179613481Sgiacomo.travaglini@arm.com (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; 179713481Sgiacomo.travaglini@arm.com} 179813481Sgiacomo.travaglini@arm.com 179913481Sgiacomo.travaglini@arm.com// Creates a Unicode code point from UTF16 surrogate pair. 180013481Sgiacomo.travaglini@arm.cominline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, 180113481Sgiacomo.travaglini@arm.com wchar_t second) { 180213481Sgiacomo.travaglini@arm.com const UInt32 mask = (1 << 10) - 1; 180313481Sgiacomo.travaglini@arm.com return (sizeof(wchar_t) == 2) ? 180413481Sgiacomo.travaglini@arm.com (((first & mask) << 10) | (second & mask)) + 0x10000 : 180513481Sgiacomo.travaglini@arm.com // This function should not be called when the condition is 180613481Sgiacomo.travaglini@arm.com // false, but we provide a sensible default in case it is. 180713481Sgiacomo.travaglini@arm.com static_cast<UInt32>(first); 180813481Sgiacomo.travaglini@arm.com} 180913481Sgiacomo.travaglini@arm.com 181013481Sgiacomo.travaglini@arm.com// Converts a wide string to a narrow string in UTF-8 encoding. 181113481Sgiacomo.travaglini@arm.com// The wide string is assumed to have the following encoding: 181213481Sgiacomo.travaglini@arm.com// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) 181313481Sgiacomo.travaglini@arm.com// UTF-32 if sizeof(wchar_t) == 4 (on Linux) 181413481Sgiacomo.travaglini@arm.com// Parameter str points to a null-terminated wide string. 181513481Sgiacomo.travaglini@arm.com// Parameter num_chars may additionally limit the number 181613481Sgiacomo.travaglini@arm.com// of wchar_t characters processed. -1 is used when the entire string 181713481Sgiacomo.travaglini@arm.com// should be processed. 181813481Sgiacomo.travaglini@arm.com// If the string contains code points that are not valid Unicode code points 181913481Sgiacomo.travaglini@arm.com// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output 182013481Sgiacomo.travaglini@arm.com// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding 182113481Sgiacomo.travaglini@arm.com// and contains invalid UTF-16 surrogate pairs, values in those pairs 182213481Sgiacomo.travaglini@arm.com// will be encoded as individual Unicode characters from Basic Normal Plane. 182313481Sgiacomo.travaglini@arm.comstd::string WideStringToUtf8(const wchar_t* str, int num_chars) { 182413481Sgiacomo.travaglini@arm.com if (num_chars == -1) 182513481Sgiacomo.travaglini@arm.com num_chars = static_cast<int>(wcslen(str)); 182613481Sgiacomo.travaglini@arm.com 182713481Sgiacomo.travaglini@arm.com ::std::stringstream stream; 182813481Sgiacomo.travaglini@arm.com for (int i = 0; i < num_chars; ++i) { 182913481Sgiacomo.travaglini@arm.com UInt32 unicode_code_point; 183013481Sgiacomo.travaglini@arm.com 183113481Sgiacomo.travaglini@arm.com if (str[i] == L'\0') { 183213481Sgiacomo.travaglini@arm.com break; 183313481Sgiacomo.travaglini@arm.com } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { 183413481Sgiacomo.travaglini@arm.com unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], 183513481Sgiacomo.travaglini@arm.com str[i + 1]); 183613481Sgiacomo.travaglini@arm.com i++; 183713481Sgiacomo.travaglini@arm.com } else { 183813481Sgiacomo.travaglini@arm.com unicode_code_point = static_cast<UInt32>(str[i]); 183913481Sgiacomo.travaglini@arm.com } 184013481Sgiacomo.travaglini@arm.com 184113481Sgiacomo.travaglini@arm.com stream << CodePointToUtf8(unicode_code_point); 184213481Sgiacomo.travaglini@arm.com } 184313481Sgiacomo.travaglini@arm.com return StringStreamToString(&stream); 184413481Sgiacomo.travaglini@arm.com} 184513481Sgiacomo.travaglini@arm.com 184613481Sgiacomo.travaglini@arm.com// Converts a wide C string to an std::string using the UTF-8 encoding. 184713481Sgiacomo.travaglini@arm.com// NULL will be converted to "(null)". 184813481Sgiacomo.travaglini@arm.comstd::string String::ShowWideCString(const wchar_t * wide_c_str) { 184913481Sgiacomo.travaglini@arm.com if (wide_c_str == NULL) return "(null)"; 185013481Sgiacomo.travaglini@arm.com 185113481Sgiacomo.travaglini@arm.com return internal::WideStringToUtf8(wide_c_str, -1); 185213481Sgiacomo.travaglini@arm.com} 185313481Sgiacomo.travaglini@arm.com 185413481Sgiacomo.travaglini@arm.com// Compares two wide C strings. Returns true iff they have the same 185513481Sgiacomo.travaglini@arm.com// content. 185613481Sgiacomo.travaglini@arm.com// 185713481Sgiacomo.travaglini@arm.com// Unlike wcscmp(), this function can handle NULL argument(s). A NULL 185813481Sgiacomo.travaglini@arm.com// C string is considered different to any non-NULL C string, 185913481Sgiacomo.travaglini@arm.com// including the empty string. 186013481Sgiacomo.travaglini@arm.combool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { 186113481Sgiacomo.travaglini@arm.com if (lhs == NULL) return rhs == NULL; 186213481Sgiacomo.travaglini@arm.com 186313481Sgiacomo.travaglini@arm.com if (rhs == NULL) return false; 186413481Sgiacomo.travaglini@arm.com 186513481Sgiacomo.travaglini@arm.com return wcscmp(lhs, rhs) == 0; 186613481Sgiacomo.travaglini@arm.com} 186713481Sgiacomo.travaglini@arm.com 186813481Sgiacomo.travaglini@arm.com// Helper function for *_STREQ on wide strings. 186913481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperSTREQ(const char* lhs_expression, 187013481Sgiacomo.travaglini@arm.com const char* rhs_expression, 187113481Sgiacomo.travaglini@arm.com const wchar_t* lhs, 187213481Sgiacomo.travaglini@arm.com const wchar_t* rhs) { 187313481Sgiacomo.travaglini@arm.com if (String::WideCStringEquals(lhs, rhs)) { 187413481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 187513481Sgiacomo.travaglini@arm.com } 187613481Sgiacomo.travaglini@arm.com 187713481Sgiacomo.travaglini@arm.com return EqFailure(lhs_expression, 187813481Sgiacomo.travaglini@arm.com rhs_expression, 187913481Sgiacomo.travaglini@arm.com PrintToString(lhs), 188013481Sgiacomo.travaglini@arm.com PrintToString(rhs), 188113481Sgiacomo.travaglini@arm.com false); 188213481Sgiacomo.travaglini@arm.com} 188313481Sgiacomo.travaglini@arm.com 188413481Sgiacomo.travaglini@arm.com// Helper function for *_STRNE on wide strings. 188513481Sgiacomo.travaglini@arm.comAssertionResult CmpHelperSTRNE(const char* s1_expression, 188613481Sgiacomo.travaglini@arm.com const char* s2_expression, 188713481Sgiacomo.travaglini@arm.com const wchar_t* s1, 188813481Sgiacomo.travaglini@arm.com const wchar_t* s2) { 188913481Sgiacomo.travaglini@arm.com if (!String::WideCStringEquals(s1, s2)) { 189013481Sgiacomo.travaglini@arm.com return AssertionSuccess(); 189113481Sgiacomo.travaglini@arm.com } 189213481Sgiacomo.travaglini@arm.com 189313481Sgiacomo.travaglini@arm.com return AssertionFailure() << "Expected: (" << s1_expression << ") != (" 189413481Sgiacomo.travaglini@arm.com << s2_expression << "), actual: " 189513481Sgiacomo.travaglini@arm.com << PrintToString(s1) 189613481Sgiacomo.travaglini@arm.com << " vs " << PrintToString(s2); 189713481Sgiacomo.travaglini@arm.com} 189813481Sgiacomo.travaglini@arm.com 189913481Sgiacomo.travaglini@arm.com// Compares two C strings, ignoring case. Returns true iff they have 190013481Sgiacomo.travaglini@arm.com// the same content. 190113481Sgiacomo.travaglini@arm.com// 190213481Sgiacomo.travaglini@arm.com// Unlike strcasecmp(), this function can handle NULL argument(s). A 190313481Sgiacomo.travaglini@arm.com// NULL C string is considered different to any non-NULL C string, 190413481Sgiacomo.travaglini@arm.com// including the empty string. 190513481Sgiacomo.travaglini@arm.combool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { 190613481Sgiacomo.travaglini@arm.com if (lhs == NULL) 190713481Sgiacomo.travaglini@arm.com return rhs == NULL; 190813481Sgiacomo.travaglini@arm.com if (rhs == NULL) 190913481Sgiacomo.travaglini@arm.com return false; 191013481Sgiacomo.travaglini@arm.com return posix::StrCaseCmp(lhs, rhs) == 0; 191113481Sgiacomo.travaglini@arm.com} 191213481Sgiacomo.travaglini@arm.com 191313481Sgiacomo.travaglini@arm.com // Compares two wide C strings, ignoring case. Returns true iff they 191413481Sgiacomo.travaglini@arm.com // have the same content. 191513481Sgiacomo.travaglini@arm.com // 191613481Sgiacomo.travaglini@arm.com // Unlike wcscasecmp(), this function can handle NULL argument(s). 191713481Sgiacomo.travaglini@arm.com // A NULL C string is considered different to any non-NULL wide C string, 191813481Sgiacomo.travaglini@arm.com // including the empty string. 191913481Sgiacomo.travaglini@arm.com // NB: The implementations on different platforms slightly differ. 192013481Sgiacomo.travaglini@arm.com // On windows, this method uses _wcsicmp which compares according to LC_CTYPE 192113481Sgiacomo.travaglini@arm.com // environment variable. On GNU platform this method uses wcscasecmp 192213481Sgiacomo.travaglini@arm.com // which compares according to LC_CTYPE category of the current locale. 192313481Sgiacomo.travaglini@arm.com // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the 192413481Sgiacomo.travaglini@arm.com // current locale. 192513481Sgiacomo.travaglini@arm.combool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, 192613481Sgiacomo.travaglini@arm.com const wchar_t* rhs) { 192713481Sgiacomo.travaglini@arm.com if (lhs == NULL) return rhs == NULL; 192813481Sgiacomo.travaglini@arm.com 192913481Sgiacomo.travaglini@arm.com if (rhs == NULL) return false; 193013481Sgiacomo.travaglini@arm.com 193113481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 193213481Sgiacomo.travaglini@arm.com return _wcsicmp(lhs, rhs) == 0; 193313481Sgiacomo.travaglini@arm.com#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID 193413481Sgiacomo.travaglini@arm.com return wcscasecmp(lhs, rhs) == 0; 193513481Sgiacomo.travaglini@arm.com#else 193613481Sgiacomo.travaglini@arm.com // Android, Mac OS X and Cygwin don't define wcscasecmp. 193713481Sgiacomo.travaglini@arm.com // Other unknown OSes may not define it either. 193813481Sgiacomo.travaglini@arm.com wint_t left, right; 193913481Sgiacomo.travaglini@arm.com do { 194013481Sgiacomo.travaglini@arm.com left = towlower(*lhs++); 194113481Sgiacomo.travaglini@arm.com right = towlower(*rhs++); 194213481Sgiacomo.travaglini@arm.com } while (left && left == right); 194313481Sgiacomo.travaglini@arm.com return left == right; 194413481Sgiacomo.travaglini@arm.com#endif // OS selector 194513481Sgiacomo.travaglini@arm.com} 194613481Sgiacomo.travaglini@arm.com 194713481Sgiacomo.travaglini@arm.com// Returns true iff str ends with the given suffix, ignoring case. 194813481Sgiacomo.travaglini@arm.com// Any string is considered to end with an empty suffix. 194913481Sgiacomo.travaglini@arm.combool String::EndsWithCaseInsensitive( 195013481Sgiacomo.travaglini@arm.com const std::string& str, const std::string& suffix) { 195113481Sgiacomo.travaglini@arm.com const size_t str_len = str.length(); 195213481Sgiacomo.travaglini@arm.com const size_t suffix_len = suffix.length(); 195313481Sgiacomo.travaglini@arm.com return (str_len >= suffix_len) && 195413481Sgiacomo.travaglini@arm.com CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len, 195513481Sgiacomo.travaglini@arm.com suffix.c_str()); 195613481Sgiacomo.travaglini@arm.com} 195713481Sgiacomo.travaglini@arm.com 195813481Sgiacomo.travaglini@arm.com// Formats an int value as "%02d". 195913481Sgiacomo.travaglini@arm.comstd::string String::FormatIntWidth2(int value) { 196013481Sgiacomo.travaglini@arm.com std::stringstream ss; 196113481Sgiacomo.travaglini@arm.com ss << std::setfill('0') << std::setw(2) << value; 196213481Sgiacomo.travaglini@arm.com return ss.str(); 196313481Sgiacomo.travaglini@arm.com} 196413481Sgiacomo.travaglini@arm.com 196513481Sgiacomo.travaglini@arm.com// Formats an int value as "%X". 196613481Sgiacomo.travaglini@arm.comstd::string String::FormatHexInt(int value) { 196713481Sgiacomo.travaglini@arm.com std::stringstream ss; 196813481Sgiacomo.travaglini@arm.com ss << std::hex << std::uppercase << value; 196913481Sgiacomo.travaglini@arm.com return ss.str(); 197013481Sgiacomo.travaglini@arm.com} 197113481Sgiacomo.travaglini@arm.com 197213481Sgiacomo.travaglini@arm.com// Formats a byte as "%02X". 197313481Sgiacomo.travaglini@arm.comstd::string String::FormatByte(unsigned char value) { 197413481Sgiacomo.travaglini@arm.com std::stringstream ss; 197513481Sgiacomo.travaglini@arm.com ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase 197613481Sgiacomo.travaglini@arm.com << static_cast<unsigned int>(value); 197713481Sgiacomo.travaglini@arm.com return ss.str(); 197813481Sgiacomo.travaglini@arm.com} 197913481Sgiacomo.travaglini@arm.com 198013481Sgiacomo.travaglini@arm.com// Converts the buffer in a stringstream to an std::string, converting NUL 198113481Sgiacomo.travaglini@arm.com// bytes to "\\0" along the way. 198213481Sgiacomo.travaglini@arm.comstd::string StringStreamToString(::std::stringstream* ss) { 198313481Sgiacomo.travaglini@arm.com const ::std::string& str = ss->str(); 198413481Sgiacomo.travaglini@arm.com const char* const start = str.c_str(); 198513481Sgiacomo.travaglini@arm.com const char* const end = start + str.length(); 198613481Sgiacomo.travaglini@arm.com 198713481Sgiacomo.travaglini@arm.com std::string result; 198813481Sgiacomo.travaglini@arm.com result.reserve(2 * (end - start)); 198913481Sgiacomo.travaglini@arm.com for (const char* ch = start; ch != end; ++ch) { 199013481Sgiacomo.travaglini@arm.com if (*ch == '\0') { 199113481Sgiacomo.travaglini@arm.com result += "\\0"; // Replaces NUL with "\\0"; 199213481Sgiacomo.travaglini@arm.com } else { 199313481Sgiacomo.travaglini@arm.com result += *ch; 199413481Sgiacomo.travaglini@arm.com } 199513481Sgiacomo.travaglini@arm.com } 199613481Sgiacomo.travaglini@arm.com 199713481Sgiacomo.travaglini@arm.com return result; 199813481Sgiacomo.travaglini@arm.com} 199913481Sgiacomo.travaglini@arm.com 200013481Sgiacomo.travaglini@arm.com// Appends the user-supplied message to the Google-Test-generated message. 200113481Sgiacomo.travaglini@arm.comstd::string AppendUserMessage(const std::string& gtest_msg, 200213481Sgiacomo.travaglini@arm.com const Message& user_msg) { 200313481Sgiacomo.travaglini@arm.com // Appends the user message if it's non-empty. 200413481Sgiacomo.travaglini@arm.com const std::string user_msg_string = user_msg.GetString(); 200513481Sgiacomo.travaglini@arm.com if (user_msg_string.empty()) { 200613481Sgiacomo.travaglini@arm.com return gtest_msg; 200713481Sgiacomo.travaglini@arm.com } 200813481Sgiacomo.travaglini@arm.com 200913481Sgiacomo.travaglini@arm.com return gtest_msg + "\n" + user_msg_string; 201013481Sgiacomo.travaglini@arm.com} 201113481Sgiacomo.travaglini@arm.com 201213481Sgiacomo.travaglini@arm.com} // namespace internal 201313481Sgiacomo.travaglini@arm.com 201413481Sgiacomo.travaglini@arm.com// class TestResult 201513481Sgiacomo.travaglini@arm.com 201613481Sgiacomo.travaglini@arm.com// Creates an empty TestResult. 201713481Sgiacomo.travaglini@arm.comTestResult::TestResult() 201813481Sgiacomo.travaglini@arm.com : death_test_count_(0), 201913481Sgiacomo.travaglini@arm.com elapsed_time_(0) { 202013481Sgiacomo.travaglini@arm.com} 202113481Sgiacomo.travaglini@arm.com 202213481Sgiacomo.travaglini@arm.com// D'tor. 202313481Sgiacomo.travaglini@arm.comTestResult::~TestResult() { 202413481Sgiacomo.travaglini@arm.com} 202513481Sgiacomo.travaglini@arm.com 202613481Sgiacomo.travaglini@arm.com// Returns the i-th test part result among all the results. i can 202713481Sgiacomo.travaglini@arm.com// range from 0 to total_part_count() - 1. If i is not in that range, 202813481Sgiacomo.travaglini@arm.com// aborts the program. 202913481Sgiacomo.travaglini@arm.comconst TestPartResult& TestResult::GetTestPartResult(int i) const { 203013481Sgiacomo.travaglini@arm.com if (i < 0 || i >= total_part_count()) 203113481Sgiacomo.travaglini@arm.com internal::posix::Abort(); 203213481Sgiacomo.travaglini@arm.com return test_part_results_.at(i); 203313481Sgiacomo.travaglini@arm.com} 203413481Sgiacomo.travaglini@arm.com 203513481Sgiacomo.travaglini@arm.com// Returns the i-th test property. i can range from 0 to 203613481Sgiacomo.travaglini@arm.com// test_property_count() - 1. If i is not in that range, aborts the 203713481Sgiacomo.travaglini@arm.com// program. 203813481Sgiacomo.travaglini@arm.comconst TestProperty& TestResult::GetTestProperty(int i) const { 203913481Sgiacomo.travaglini@arm.com if (i < 0 || i >= test_property_count()) 204013481Sgiacomo.travaglini@arm.com internal::posix::Abort(); 204113481Sgiacomo.travaglini@arm.com return test_properties_.at(i); 204213481Sgiacomo.travaglini@arm.com} 204313481Sgiacomo.travaglini@arm.com 204413481Sgiacomo.travaglini@arm.com// Clears the test part results. 204513481Sgiacomo.travaglini@arm.comvoid TestResult::ClearTestPartResults() { 204613481Sgiacomo.travaglini@arm.com test_part_results_.clear(); 204713481Sgiacomo.travaglini@arm.com} 204813481Sgiacomo.travaglini@arm.com 204913481Sgiacomo.travaglini@arm.com// Adds a test part result to the list. 205013481Sgiacomo.travaglini@arm.comvoid TestResult::AddTestPartResult(const TestPartResult& test_part_result) { 205113481Sgiacomo.travaglini@arm.com test_part_results_.push_back(test_part_result); 205213481Sgiacomo.travaglini@arm.com} 205313481Sgiacomo.travaglini@arm.com 205413481Sgiacomo.travaglini@arm.com// Adds a test property to the list. If a property with the same key as the 205513481Sgiacomo.travaglini@arm.com// supplied property is already represented, the value of this test_property 205613481Sgiacomo.travaglini@arm.com// replaces the old value for that key. 205713481Sgiacomo.travaglini@arm.comvoid TestResult::RecordProperty(const std::string& xml_element, 205813481Sgiacomo.travaglini@arm.com const TestProperty& test_property) { 205913481Sgiacomo.travaglini@arm.com if (!ValidateTestProperty(xml_element, test_property)) { 206013481Sgiacomo.travaglini@arm.com return; 206113481Sgiacomo.travaglini@arm.com } 206213481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&test_properites_mutex_); 206313481Sgiacomo.travaglini@arm.com const std::vector<TestProperty>::iterator property_with_matching_key = 206413481Sgiacomo.travaglini@arm.com std::find_if(test_properties_.begin(), test_properties_.end(), 206513481Sgiacomo.travaglini@arm.com internal::TestPropertyKeyIs(test_property.key())); 206613481Sgiacomo.travaglini@arm.com if (property_with_matching_key == test_properties_.end()) { 206713481Sgiacomo.travaglini@arm.com test_properties_.push_back(test_property); 206813481Sgiacomo.travaglini@arm.com return; 206913481Sgiacomo.travaglini@arm.com } 207013481Sgiacomo.travaglini@arm.com property_with_matching_key->SetValue(test_property.value()); 207113481Sgiacomo.travaglini@arm.com} 207213481Sgiacomo.travaglini@arm.com 207313481Sgiacomo.travaglini@arm.com// The list of reserved attributes used in the <testsuites> element of XML 207413481Sgiacomo.travaglini@arm.com// output. 207513481Sgiacomo.travaglini@arm.comstatic const char* const kReservedTestSuitesAttributes[] = { 207613481Sgiacomo.travaglini@arm.com "disabled", 207713481Sgiacomo.travaglini@arm.com "errors", 207813481Sgiacomo.travaglini@arm.com "failures", 207913481Sgiacomo.travaglini@arm.com "name", 208013481Sgiacomo.travaglini@arm.com "random_seed", 208113481Sgiacomo.travaglini@arm.com "tests", 208213481Sgiacomo.travaglini@arm.com "time", 208313481Sgiacomo.travaglini@arm.com "timestamp" 208413481Sgiacomo.travaglini@arm.com}; 208513481Sgiacomo.travaglini@arm.com 208613481Sgiacomo.travaglini@arm.com// The list of reserved attributes used in the <testsuite> element of XML 208713481Sgiacomo.travaglini@arm.com// output. 208813481Sgiacomo.travaglini@arm.comstatic const char* const kReservedTestSuiteAttributes[] = { 208913481Sgiacomo.travaglini@arm.com "disabled", 209013481Sgiacomo.travaglini@arm.com "errors", 209113481Sgiacomo.travaglini@arm.com "failures", 209213481Sgiacomo.travaglini@arm.com "name", 209313481Sgiacomo.travaglini@arm.com "tests", 209413481Sgiacomo.travaglini@arm.com "time" 209513481Sgiacomo.travaglini@arm.com}; 209613481Sgiacomo.travaglini@arm.com 209713481Sgiacomo.travaglini@arm.com// The list of reserved attributes used in the <testcase> element of XML output. 209813481Sgiacomo.travaglini@arm.comstatic const char* const kReservedTestCaseAttributes[] = { 209913481Sgiacomo.travaglini@arm.com "classname", 210013481Sgiacomo.travaglini@arm.com "name", 210113481Sgiacomo.travaglini@arm.com "status", 210213481Sgiacomo.travaglini@arm.com "time", 210313481Sgiacomo.travaglini@arm.com "type_param", 210413481Sgiacomo.travaglini@arm.com "value_param" 210513481Sgiacomo.travaglini@arm.com}; 210613481Sgiacomo.travaglini@arm.com 210713481Sgiacomo.travaglini@arm.comtemplate <int kSize> 210813481Sgiacomo.travaglini@arm.comstd::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) { 210913481Sgiacomo.travaglini@arm.com return std::vector<std::string>(array, array + kSize); 211013481Sgiacomo.travaglini@arm.com} 211113481Sgiacomo.travaglini@arm.com 211213481Sgiacomo.travaglini@arm.comstatic std::vector<std::string> GetReservedAttributesForElement( 211313481Sgiacomo.travaglini@arm.com const std::string& xml_element) { 211413481Sgiacomo.travaglini@arm.com if (xml_element == "testsuites") { 211513481Sgiacomo.travaglini@arm.com return ArrayAsVector(kReservedTestSuitesAttributes); 211613481Sgiacomo.travaglini@arm.com } else if (xml_element == "testsuite") { 211713481Sgiacomo.travaglini@arm.com return ArrayAsVector(kReservedTestSuiteAttributes); 211813481Sgiacomo.travaglini@arm.com } else if (xml_element == "testcase") { 211913481Sgiacomo.travaglini@arm.com return ArrayAsVector(kReservedTestCaseAttributes); 212013481Sgiacomo.travaglini@arm.com } else { 212113481Sgiacomo.travaglini@arm.com GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; 212213481Sgiacomo.travaglini@arm.com } 212313481Sgiacomo.travaglini@arm.com // This code is unreachable but some compilers may not realizes that. 212413481Sgiacomo.travaglini@arm.com return std::vector<std::string>(); 212513481Sgiacomo.travaglini@arm.com} 212613481Sgiacomo.travaglini@arm.com 212713481Sgiacomo.travaglini@arm.comstatic std::string FormatWordList(const std::vector<std::string>& words) { 212813481Sgiacomo.travaglini@arm.com Message word_list; 212913481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < words.size(); ++i) { 213013481Sgiacomo.travaglini@arm.com if (i > 0 && words.size() > 2) { 213113481Sgiacomo.travaglini@arm.com word_list << ", "; 213213481Sgiacomo.travaglini@arm.com } 213313481Sgiacomo.travaglini@arm.com if (i == words.size() - 1) { 213413481Sgiacomo.travaglini@arm.com word_list << "and "; 213513481Sgiacomo.travaglini@arm.com } 213613481Sgiacomo.travaglini@arm.com word_list << "'" << words[i] << "'"; 213713481Sgiacomo.travaglini@arm.com } 213813481Sgiacomo.travaglini@arm.com return word_list.GetString(); 213913481Sgiacomo.travaglini@arm.com} 214013481Sgiacomo.travaglini@arm.com 214113481Sgiacomo.travaglini@arm.combool ValidateTestPropertyName(const std::string& property_name, 214213481Sgiacomo.travaglini@arm.com const std::vector<std::string>& reserved_names) { 214313481Sgiacomo.travaglini@arm.com if (std::find(reserved_names.begin(), reserved_names.end(), property_name) != 214413481Sgiacomo.travaglini@arm.com reserved_names.end()) { 214513481Sgiacomo.travaglini@arm.com ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name 214613481Sgiacomo.travaglini@arm.com << " (" << FormatWordList(reserved_names) 214713481Sgiacomo.travaglini@arm.com << " are reserved by " << GTEST_NAME_ << ")"; 214813481Sgiacomo.travaglini@arm.com return false; 214913481Sgiacomo.travaglini@arm.com } 215013481Sgiacomo.travaglini@arm.com return true; 215113481Sgiacomo.travaglini@arm.com} 215213481Sgiacomo.travaglini@arm.com 215313481Sgiacomo.travaglini@arm.com// Adds a failure if the key is a reserved attribute of the element named 215413481Sgiacomo.travaglini@arm.com// xml_element. Returns true if the property is valid. 215513481Sgiacomo.travaglini@arm.combool TestResult::ValidateTestProperty(const std::string& xml_element, 215613481Sgiacomo.travaglini@arm.com const TestProperty& test_property) { 215713481Sgiacomo.travaglini@arm.com return ValidateTestPropertyName(test_property.key(), 215813481Sgiacomo.travaglini@arm.com GetReservedAttributesForElement(xml_element)); 215913481Sgiacomo.travaglini@arm.com} 216013481Sgiacomo.travaglini@arm.com 216113481Sgiacomo.travaglini@arm.com// Clears the object. 216213481Sgiacomo.travaglini@arm.comvoid TestResult::Clear() { 216313481Sgiacomo.travaglini@arm.com test_part_results_.clear(); 216413481Sgiacomo.travaglini@arm.com test_properties_.clear(); 216513481Sgiacomo.travaglini@arm.com death_test_count_ = 0; 216613481Sgiacomo.travaglini@arm.com elapsed_time_ = 0; 216713481Sgiacomo.travaglini@arm.com} 216813481Sgiacomo.travaglini@arm.com 216913481Sgiacomo.travaglini@arm.com// Returns true iff the test failed. 217013481Sgiacomo.travaglini@arm.combool TestResult::Failed() const { 217113481Sgiacomo.travaglini@arm.com for (int i = 0; i < total_part_count(); ++i) { 217213481Sgiacomo.travaglini@arm.com if (GetTestPartResult(i).failed()) 217313481Sgiacomo.travaglini@arm.com return true; 217413481Sgiacomo.travaglini@arm.com } 217513481Sgiacomo.travaglini@arm.com return false; 217613481Sgiacomo.travaglini@arm.com} 217713481Sgiacomo.travaglini@arm.com 217813481Sgiacomo.travaglini@arm.com// Returns true iff the test part fatally failed. 217913481Sgiacomo.travaglini@arm.comstatic bool TestPartFatallyFailed(const TestPartResult& result) { 218013481Sgiacomo.travaglini@arm.com return result.fatally_failed(); 218113481Sgiacomo.travaglini@arm.com} 218213481Sgiacomo.travaglini@arm.com 218313481Sgiacomo.travaglini@arm.com// Returns true iff the test fatally failed. 218413481Sgiacomo.travaglini@arm.combool TestResult::HasFatalFailure() const { 218513481Sgiacomo.travaglini@arm.com return CountIf(test_part_results_, TestPartFatallyFailed) > 0; 218613481Sgiacomo.travaglini@arm.com} 218713481Sgiacomo.travaglini@arm.com 218813481Sgiacomo.travaglini@arm.com// Returns true iff the test part non-fatally failed. 218913481Sgiacomo.travaglini@arm.comstatic bool TestPartNonfatallyFailed(const TestPartResult& result) { 219013481Sgiacomo.travaglini@arm.com return result.nonfatally_failed(); 219113481Sgiacomo.travaglini@arm.com} 219213481Sgiacomo.travaglini@arm.com 219313481Sgiacomo.travaglini@arm.com// Returns true iff the test has a non-fatal failure. 219413481Sgiacomo.travaglini@arm.combool TestResult::HasNonfatalFailure() const { 219513481Sgiacomo.travaglini@arm.com return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; 219613481Sgiacomo.travaglini@arm.com} 219713481Sgiacomo.travaglini@arm.com 219813481Sgiacomo.travaglini@arm.com// Gets the number of all test parts. This is the sum of the number 219913481Sgiacomo.travaglini@arm.com// of successful test parts and the number of failed test parts. 220013481Sgiacomo.travaglini@arm.comint TestResult::total_part_count() const { 220113481Sgiacomo.travaglini@arm.com return static_cast<int>(test_part_results_.size()); 220213481Sgiacomo.travaglini@arm.com} 220313481Sgiacomo.travaglini@arm.com 220413481Sgiacomo.travaglini@arm.com// Returns the number of the test properties. 220513481Sgiacomo.travaglini@arm.comint TestResult::test_property_count() const { 220613481Sgiacomo.travaglini@arm.com return static_cast<int>(test_properties_.size()); 220713481Sgiacomo.travaglini@arm.com} 220813481Sgiacomo.travaglini@arm.com 220913481Sgiacomo.travaglini@arm.com// class Test 221013481Sgiacomo.travaglini@arm.com 221113481Sgiacomo.travaglini@arm.com// Creates a Test object. 221213481Sgiacomo.travaglini@arm.com 221313481Sgiacomo.travaglini@arm.com// The c'tor saves the states of all flags. 221413481Sgiacomo.travaglini@arm.comTest::Test() 221513481Sgiacomo.travaglini@arm.com : gtest_flag_saver_(new GTEST_FLAG_SAVER_) { 221613481Sgiacomo.travaglini@arm.com} 221713481Sgiacomo.travaglini@arm.com 221813481Sgiacomo.travaglini@arm.com// The d'tor restores the states of all flags. The actual work is 221913481Sgiacomo.travaglini@arm.com// done by the d'tor of the gtest_flag_saver_ field, and thus not 222013481Sgiacomo.travaglini@arm.com// visible here. 222113481Sgiacomo.travaglini@arm.comTest::~Test() { 222213481Sgiacomo.travaglini@arm.com} 222313481Sgiacomo.travaglini@arm.com 222413481Sgiacomo.travaglini@arm.com// Sets up the test fixture. 222513481Sgiacomo.travaglini@arm.com// 222613481Sgiacomo.travaglini@arm.com// A sub-class may override this. 222713481Sgiacomo.travaglini@arm.comvoid Test::SetUp() { 222813481Sgiacomo.travaglini@arm.com} 222913481Sgiacomo.travaglini@arm.com 223013481Sgiacomo.travaglini@arm.com// Tears down the test fixture. 223113481Sgiacomo.travaglini@arm.com// 223213481Sgiacomo.travaglini@arm.com// A sub-class may override this. 223313481Sgiacomo.travaglini@arm.comvoid Test::TearDown() { 223413481Sgiacomo.travaglini@arm.com} 223513481Sgiacomo.travaglini@arm.com 223613481Sgiacomo.travaglini@arm.com// Allows user supplied key value pairs to be recorded for later output. 223713481Sgiacomo.travaglini@arm.comvoid Test::RecordProperty(const std::string& key, const std::string& value) { 223813481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()->RecordProperty(key, value); 223913481Sgiacomo.travaglini@arm.com} 224013481Sgiacomo.travaglini@arm.com 224113481Sgiacomo.travaglini@arm.com// Allows user supplied key value pairs to be recorded for later output. 224213481Sgiacomo.travaglini@arm.comvoid Test::RecordProperty(const std::string& key, int value) { 224313481Sgiacomo.travaglini@arm.com Message value_message; 224413481Sgiacomo.travaglini@arm.com value_message << value; 224513481Sgiacomo.travaglini@arm.com RecordProperty(key, value_message.GetString().c_str()); 224613481Sgiacomo.travaglini@arm.com} 224713481Sgiacomo.travaglini@arm.com 224813481Sgiacomo.travaglini@arm.comnamespace internal { 224913481Sgiacomo.travaglini@arm.com 225013481Sgiacomo.travaglini@arm.comvoid ReportFailureInUnknownLocation(TestPartResult::Type result_type, 225113481Sgiacomo.travaglini@arm.com const std::string& message) { 225213481Sgiacomo.travaglini@arm.com // This function is a friend of UnitTest and as such has access to 225313481Sgiacomo.travaglini@arm.com // AddTestPartResult. 225413481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()->AddTestPartResult( 225513481Sgiacomo.travaglini@arm.com result_type, 225613481Sgiacomo.travaglini@arm.com NULL, // No info about the source file where the exception occurred. 225713481Sgiacomo.travaglini@arm.com -1, // We have no info on which line caused the exception. 225813481Sgiacomo.travaglini@arm.com message, 225913481Sgiacomo.travaglini@arm.com ""); // No stack trace, either. 226013481Sgiacomo.travaglini@arm.com} 226113481Sgiacomo.travaglini@arm.com 226213481Sgiacomo.travaglini@arm.com} // namespace internal 226313481Sgiacomo.travaglini@arm.com 226413481Sgiacomo.travaglini@arm.com// Google Test requires all tests in the same test case to use the same test 226513481Sgiacomo.travaglini@arm.com// fixture class. This function checks if the current test has the 226613481Sgiacomo.travaglini@arm.com// same fixture class as the first test in the current test case. If 226713481Sgiacomo.travaglini@arm.com// yes, it returns true; otherwise it generates a Google Test failure and 226813481Sgiacomo.travaglini@arm.com// returns false. 226913481Sgiacomo.travaglini@arm.combool Test::HasSameFixtureClass() { 227013481Sgiacomo.travaglini@arm.com internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 227113481Sgiacomo.travaglini@arm.com const TestCase* const test_case = impl->current_test_case(); 227213481Sgiacomo.travaglini@arm.com 227313481Sgiacomo.travaglini@arm.com // Info about the first test in the current test case. 227413481Sgiacomo.travaglini@arm.com const TestInfo* const first_test_info = test_case->test_info_list()[0]; 227513481Sgiacomo.travaglini@arm.com const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; 227613481Sgiacomo.travaglini@arm.com const char* const first_test_name = first_test_info->name(); 227713481Sgiacomo.travaglini@arm.com 227813481Sgiacomo.travaglini@arm.com // Info about the current test. 227913481Sgiacomo.travaglini@arm.com const TestInfo* const this_test_info = impl->current_test_info(); 228013481Sgiacomo.travaglini@arm.com const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; 228113481Sgiacomo.travaglini@arm.com const char* const this_test_name = this_test_info->name(); 228213481Sgiacomo.travaglini@arm.com 228313481Sgiacomo.travaglini@arm.com if (this_fixture_id != first_fixture_id) { 228413481Sgiacomo.travaglini@arm.com // Is the first test defined using TEST? 228513481Sgiacomo.travaglini@arm.com const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); 228613481Sgiacomo.travaglini@arm.com // Is this test defined using TEST? 228713481Sgiacomo.travaglini@arm.com const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); 228813481Sgiacomo.travaglini@arm.com 228913481Sgiacomo.travaglini@arm.com if (first_is_TEST || this_is_TEST) { 229013481Sgiacomo.travaglini@arm.com // Both TEST and TEST_F appear in same test case, which is incorrect. 229113481Sgiacomo.travaglini@arm.com // Tell the user how to fix this. 229213481Sgiacomo.travaglini@arm.com 229313481Sgiacomo.travaglini@arm.com // Gets the name of the TEST and the name of the TEST_F. Note 229413481Sgiacomo.travaglini@arm.com // that first_is_TEST and this_is_TEST cannot both be true, as 229513481Sgiacomo.travaglini@arm.com // the fixture IDs are different for the two tests. 229613481Sgiacomo.travaglini@arm.com const char* const TEST_name = 229713481Sgiacomo.travaglini@arm.com first_is_TEST ? first_test_name : this_test_name; 229813481Sgiacomo.travaglini@arm.com const char* const TEST_F_name = 229913481Sgiacomo.travaglini@arm.com first_is_TEST ? this_test_name : first_test_name; 230013481Sgiacomo.travaglini@arm.com 230113481Sgiacomo.travaglini@arm.com ADD_FAILURE() 230213481Sgiacomo.travaglini@arm.com << "All tests in the same test case must use the same test fixture\n" 230313481Sgiacomo.travaglini@arm.com << "class, so mixing TEST_F and TEST in the same test case is\n" 230413481Sgiacomo.travaglini@arm.com << "illegal. In test case " << this_test_info->test_case_name() 230513481Sgiacomo.travaglini@arm.com << ",\n" 230613481Sgiacomo.travaglini@arm.com << "test " << TEST_F_name << " is defined using TEST_F but\n" 230713481Sgiacomo.travaglini@arm.com << "test " << TEST_name << " is defined using TEST. You probably\n" 230813481Sgiacomo.travaglini@arm.com << "want to change the TEST to TEST_F or move it to another test\n" 230913481Sgiacomo.travaglini@arm.com << "case."; 231013481Sgiacomo.travaglini@arm.com } else { 231113481Sgiacomo.travaglini@arm.com // Two fixture classes with the same name appear in two different 231213481Sgiacomo.travaglini@arm.com // namespaces, which is not allowed. Tell the user how to fix this. 231313481Sgiacomo.travaglini@arm.com ADD_FAILURE() 231413481Sgiacomo.travaglini@arm.com << "All tests in the same test case must use the same test fixture\n" 231513481Sgiacomo.travaglini@arm.com << "class. However, in test case " 231613481Sgiacomo.travaglini@arm.com << this_test_info->test_case_name() << ",\n" 231713481Sgiacomo.travaglini@arm.com << "you defined test " << first_test_name 231813481Sgiacomo.travaglini@arm.com << " and test " << this_test_name << "\n" 231913481Sgiacomo.travaglini@arm.com << "using two different test fixture classes. This can happen if\n" 232013481Sgiacomo.travaglini@arm.com << "the two classes are from different namespaces or translation\n" 232113481Sgiacomo.travaglini@arm.com << "units and have the same name. You should probably rename one\n" 232213481Sgiacomo.travaglini@arm.com << "of the classes to put the tests into different test cases."; 232313481Sgiacomo.travaglini@arm.com } 232413481Sgiacomo.travaglini@arm.com return false; 232513481Sgiacomo.travaglini@arm.com } 232613481Sgiacomo.travaglini@arm.com 232713481Sgiacomo.travaglini@arm.com return true; 232813481Sgiacomo.travaglini@arm.com} 232913481Sgiacomo.travaglini@arm.com 233013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_SEH 233113481Sgiacomo.travaglini@arm.com 233213481Sgiacomo.travaglini@arm.com// Adds an "exception thrown" fatal failure to the current test. This 233313481Sgiacomo.travaglini@arm.com// function returns its result via an output parameter pointer because VC++ 233413481Sgiacomo.travaglini@arm.com// prohibits creation of objects with destructors on stack in functions 233513481Sgiacomo.travaglini@arm.com// using __try (see error C2712). 233613481Sgiacomo.travaglini@arm.comstatic std::string* FormatSehExceptionMessage(DWORD exception_code, 233713481Sgiacomo.travaglini@arm.com const char* location) { 233813481Sgiacomo.travaglini@arm.com Message message; 233913481Sgiacomo.travaglini@arm.com message << "SEH exception with code 0x" << std::setbase(16) << 234013481Sgiacomo.travaglini@arm.com exception_code << std::setbase(10) << " thrown in " << location << "."; 234113481Sgiacomo.travaglini@arm.com 234213481Sgiacomo.travaglini@arm.com return new std::string(message.GetString()); 234313481Sgiacomo.travaglini@arm.com} 234413481Sgiacomo.travaglini@arm.com 234513481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_SEH 234613481Sgiacomo.travaglini@arm.com 234713481Sgiacomo.travaglini@arm.comnamespace internal { 234813481Sgiacomo.travaglini@arm.com 234913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 235013481Sgiacomo.travaglini@arm.com 235113481Sgiacomo.travaglini@arm.com// Adds an "exception thrown" fatal failure to the current test. 235213481Sgiacomo.travaglini@arm.comstatic std::string FormatCxxExceptionMessage(const char* description, 235313481Sgiacomo.travaglini@arm.com const char* location) { 235413481Sgiacomo.travaglini@arm.com Message message; 235513481Sgiacomo.travaglini@arm.com if (description != NULL) { 235613481Sgiacomo.travaglini@arm.com message << "C++ exception with description \"" << description << "\""; 235713481Sgiacomo.travaglini@arm.com } else { 235813481Sgiacomo.travaglini@arm.com message << "Unknown C++ exception"; 235913481Sgiacomo.travaglini@arm.com } 236013481Sgiacomo.travaglini@arm.com message << " thrown in " << location << "."; 236113481Sgiacomo.travaglini@arm.com 236213481Sgiacomo.travaglini@arm.com return message.GetString(); 236313481Sgiacomo.travaglini@arm.com} 236413481Sgiacomo.travaglini@arm.com 236513481Sgiacomo.travaglini@arm.comstatic std::string PrintTestPartResultToString( 236613481Sgiacomo.travaglini@arm.com const TestPartResult& test_part_result); 236713481Sgiacomo.travaglini@arm.com 236813481Sgiacomo.travaglini@arm.comGoogleTestFailureException::GoogleTestFailureException( 236913481Sgiacomo.travaglini@arm.com const TestPartResult& failure) 237013481Sgiacomo.travaglini@arm.com : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} 237113481Sgiacomo.travaglini@arm.com 237213481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_EXCEPTIONS 237313481Sgiacomo.travaglini@arm.com 237413481Sgiacomo.travaglini@arm.com// We put these helper functions in the internal namespace as IBM's xlC 237513481Sgiacomo.travaglini@arm.com// compiler rejects the code if they were declared static. 237613481Sgiacomo.travaglini@arm.com 237713481Sgiacomo.travaglini@arm.com// Runs the given method and handles SEH exceptions it throws, when 237813481Sgiacomo.travaglini@arm.com// SEH is supported; returns the 0-value for type Result in case of an 237913481Sgiacomo.travaglini@arm.com// SEH exception. (Microsoft compilers cannot handle SEH and C++ 238013481Sgiacomo.travaglini@arm.com// exceptions in the same function. Therefore, we provide a separate 238113481Sgiacomo.travaglini@arm.com// wrapper function for handling SEH exceptions.) 238213481Sgiacomo.travaglini@arm.comtemplate <class T, typename Result> 238313481Sgiacomo.travaglini@arm.comResult HandleSehExceptionsInMethodIfSupported( 238413481Sgiacomo.travaglini@arm.com T* object, Result (T::*method)(), const char* location) { 238513481Sgiacomo.travaglini@arm.com#if GTEST_HAS_SEH 238613481Sgiacomo.travaglini@arm.com __try { 238713481Sgiacomo.travaglini@arm.com return (object->*method)(); 238813481Sgiacomo.travaglini@arm.com } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT 238913481Sgiacomo.travaglini@arm.com GetExceptionCode())) { 239013481Sgiacomo.travaglini@arm.com // We create the exception message on the heap because VC++ prohibits 239113481Sgiacomo.travaglini@arm.com // creation of objects with destructors on stack in functions using __try 239213481Sgiacomo.travaglini@arm.com // (see error C2712). 239313481Sgiacomo.travaglini@arm.com std::string* exception_message = FormatSehExceptionMessage( 239413481Sgiacomo.travaglini@arm.com GetExceptionCode(), location); 239513481Sgiacomo.travaglini@arm.com internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, 239613481Sgiacomo.travaglini@arm.com *exception_message); 239713481Sgiacomo.travaglini@arm.com delete exception_message; 239813481Sgiacomo.travaglini@arm.com return static_cast<Result>(0); 239913481Sgiacomo.travaglini@arm.com } 240013481Sgiacomo.travaglini@arm.com#else 240113481Sgiacomo.travaglini@arm.com (void)location; 240213481Sgiacomo.travaglini@arm.com return (object->*method)(); 240313481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_SEH 240413481Sgiacomo.travaglini@arm.com} 240513481Sgiacomo.travaglini@arm.com 240613481Sgiacomo.travaglini@arm.com// Runs the given method and catches and reports C++ and/or SEH-style 240713481Sgiacomo.travaglini@arm.com// exceptions, if they are supported; returns the 0-value for type 240813481Sgiacomo.travaglini@arm.com// Result in case of an SEH exception. 240913481Sgiacomo.travaglini@arm.comtemplate <class T, typename Result> 241013481Sgiacomo.travaglini@arm.comResult HandleExceptionsInMethodIfSupported( 241113481Sgiacomo.travaglini@arm.com T* object, Result (T::*method)(), const char* location) { 241213481Sgiacomo.travaglini@arm.com // NOTE: The user code can affect the way in which Google Test handles 241313481Sgiacomo.travaglini@arm.com // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 241413481Sgiacomo.travaglini@arm.com // RUN_ALL_TESTS() starts. It is technically possible to check the flag 241513481Sgiacomo.travaglini@arm.com // after the exception is caught and either report or re-throw the 241613481Sgiacomo.travaglini@arm.com // exception based on the flag's value: 241713481Sgiacomo.travaglini@arm.com // 241813481Sgiacomo.travaglini@arm.com // try { 241913481Sgiacomo.travaglini@arm.com // // Perform the test method. 242013481Sgiacomo.travaglini@arm.com // } catch (...) { 242113481Sgiacomo.travaglini@arm.com // if (GTEST_FLAG(catch_exceptions)) 242213481Sgiacomo.travaglini@arm.com // // Report the exception as failure. 242313481Sgiacomo.travaglini@arm.com // else 242413481Sgiacomo.travaglini@arm.com // throw; // Re-throws the original exception. 242513481Sgiacomo.travaglini@arm.com // } 242613481Sgiacomo.travaglini@arm.com // 242713481Sgiacomo.travaglini@arm.com // However, the purpose of this flag is to allow the program to drop into 242813481Sgiacomo.travaglini@arm.com // the debugger when the exception is thrown. On most platforms, once the 242913481Sgiacomo.travaglini@arm.com // control enters the catch block, the exception origin information is 243013481Sgiacomo.travaglini@arm.com // lost and the debugger will stop the program at the point of the 243113481Sgiacomo.travaglini@arm.com // re-throw in this function -- instead of at the point of the original 243213481Sgiacomo.travaglini@arm.com // throw statement in the code under test. For this reason, we perform 243313481Sgiacomo.travaglini@arm.com // the check early, sacrificing the ability to affect Google Test's 243413481Sgiacomo.travaglini@arm.com // exception handling in the method where the exception is thrown. 243513481Sgiacomo.travaglini@arm.com if (internal::GetUnitTestImpl()->catch_exceptions()) { 243613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 243713481Sgiacomo.travaglini@arm.com try { 243813481Sgiacomo.travaglini@arm.com return HandleSehExceptionsInMethodIfSupported(object, method, location); 243913481Sgiacomo.travaglini@arm.com } catch (const internal::GoogleTestFailureException&) { // NOLINT 244013481Sgiacomo.travaglini@arm.com // This exception type can only be thrown by a failed Google 244113481Sgiacomo.travaglini@arm.com // Test assertion with the intention of letting another testing 244213481Sgiacomo.travaglini@arm.com // framework catch it. Therefore we just re-throw it. 244313481Sgiacomo.travaglini@arm.com throw; 244413481Sgiacomo.travaglini@arm.com } catch (const std::exception& e) { // NOLINT 244513481Sgiacomo.travaglini@arm.com internal::ReportFailureInUnknownLocation( 244613481Sgiacomo.travaglini@arm.com TestPartResult::kFatalFailure, 244713481Sgiacomo.travaglini@arm.com FormatCxxExceptionMessage(e.what(), location)); 244813481Sgiacomo.travaglini@arm.com } catch (...) { // NOLINT 244913481Sgiacomo.travaglini@arm.com internal::ReportFailureInUnknownLocation( 245013481Sgiacomo.travaglini@arm.com TestPartResult::kFatalFailure, 245113481Sgiacomo.travaglini@arm.com FormatCxxExceptionMessage(NULL, location)); 245213481Sgiacomo.travaglini@arm.com } 245313481Sgiacomo.travaglini@arm.com return static_cast<Result>(0); 245413481Sgiacomo.travaglini@arm.com#else 245513481Sgiacomo.travaglini@arm.com return HandleSehExceptionsInMethodIfSupported(object, method, location); 245613481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_EXCEPTIONS 245713481Sgiacomo.travaglini@arm.com } else { 245813481Sgiacomo.travaglini@arm.com return (object->*method)(); 245913481Sgiacomo.travaglini@arm.com } 246013481Sgiacomo.travaglini@arm.com} 246113481Sgiacomo.travaglini@arm.com 246213481Sgiacomo.travaglini@arm.com} // namespace internal 246313481Sgiacomo.travaglini@arm.com 246413481Sgiacomo.travaglini@arm.com// Runs the test and updates the test result. 246513481Sgiacomo.travaglini@arm.comvoid Test::Run() { 246613481Sgiacomo.travaglini@arm.com if (!HasSameFixtureClass()) return; 246713481Sgiacomo.travaglini@arm.com 246813481Sgiacomo.travaglini@arm.com internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 246913481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 247013481Sgiacomo.travaglini@arm.com internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); 247113481Sgiacomo.travaglini@arm.com // We will run the test only if SetUp() was successful. 247213481Sgiacomo.travaglini@arm.com if (!HasFatalFailure()) { 247313481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 247413481Sgiacomo.travaglini@arm.com internal::HandleExceptionsInMethodIfSupported( 247513481Sgiacomo.travaglini@arm.com this, &Test::TestBody, "the test body"); 247613481Sgiacomo.travaglini@arm.com } 247713481Sgiacomo.travaglini@arm.com 247813481Sgiacomo.travaglini@arm.com // However, we want to clean up as much as possible. Hence we will 247913481Sgiacomo.travaglini@arm.com // always call TearDown(), even if SetUp() or the test body has 248013481Sgiacomo.travaglini@arm.com // failed. 248113481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 248213481Sgiacomo.travaglini@arm.com internal::HandleExceptionsInMethodIfSupported( 248313481Sgiacomo.travaglini@arm.com this, &Test::TearDown, "TearDown()"); 248413481Sgiacomo.travaglini@arm.com} 248513481Sgiacomo.travaglini@arm.com 248613481Sgiacomo.travaglini@arm.com// Returns true iff the current test has a fatal failure. 248713481Sgiacomo.travaglini@arm.combool Test::HasFatalFailure() { 248813481Sgiacomo.travaglini@arm.com return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); 248913481Sgiacomo.travaglini@arm.com} 249013481Sgiacomo.travaglini@arm.com 249113481Sgiacomo.travaglini@arm.com// Returns true iff the current test has a non-fatal failure. 249213481Sgiacomo.travaglini@arm.combool Test::HasNonfatalFailure() { 249313481Sgiacomo.travaglini@arm.com return internal::GetUnitTestImpl()->current_test_result()-> 249413481Sgiacomo.travaglini@arm.com HasNonfatalFailure(); 249513481Sgiacomo.travaglini@arm.com} 249613481Sgiacomo.travaglini@arm.com 249713481Sgiacomo.travaglini@arm.com// class TestInfo 249813481Sgiacomo.travaglini@arm.com 249913481Sgiacomo.travaglini@arm.com// Constructs a TestInfo object. It assumes ownership of the test factory 250013481Sgiacomo.travaglini@arm.com// object. 250113481Sgiacomo.travaglini@arm.comTestInfo::TestInfo(const std::string& a_test_case_name, 250213481Sgiacomo.travaglini@arm.com const std::string& a_name, 250313481Sgiacomo.travaglini@arm.com const char* a_type_param, 250413481Sgiacomo.travaglini@arm.com const char* a_value_param, 250513481Sgiacomo.travaglini@arm.com internal::CodeLocation a_code_location, 250613481Sgiacomo.travaglini@arm.com internal::TypeId fixture_class_id, 250713481Sgiacomo.travaglini@arm.com internal::TestFactoryBase* factory) 250813481Sgiacomo.travaglini@arm.com : test_case_name_(a_test_case_name), 250913481Sgiacomo.travaglini@arm.com name_(a_name), 251013481Sgiacomo.travaglini@arm.com type_param_(a_type_param ? new std::string(a_type_param) : NULL), 251113481Sgiacomo.travaglini@arm.com value_param_(a_value_param ? new std::string(a_value_param) : NULL), 251213481Sgiacomo.travaglini@arm.com location_(a_code_location), 251313481Sgiacomo.travaglini@arm.com fixture_class_id_(fixture_class_id), 251413481Sgiacomo.travaglini@arm.com should_run_(false), 251513481Sgiacomo.travaglini@arm.com is_disabled_(false), 251613481Sgiacomo.travaglini@arm.com matches_filter_(false), 251713481Sgiacomo.travaglini@arm.com factory_(factory), 251813481Sgiacomo.travaglini@arm.com result_() {} 251913481Sgiacomo.travaglini@arm.com 252013481Sgiacomo.travaglini@arm.com// Destructs a TestInfo object. 252113481Sgiacomo.travaglini@arm.comTestInfo::~TestInfo() { delete factory_; } 252213481Sgiacomo.travaglini@arm.com 252313481Sgiacomo.travaglini@arm.comnamespace internal { 252413481Sgiacomo.travaglini@arm.com 252513481Sgiacomo.travaglini@arm.com// Creates a new TestInfo object and registers it with Google Test; 252613481Sgiacomo.travaglini@arm.com// returns the created object. 252713481Sgiacomo.travaglini@arm.com// 252813481Sgiacomo.travaglini@arm.com// Arguments: 252913481Sgiacomo.travaglini@arm.com// 253013481Sgiacomo.travaglini@arm.com// test_case_name: name of the test case 253113481Sgiacomo.travaglini@arm.com// name: name of the test 253213481Sgiacomo.travaglini@arm.com// type_param: the name of the test's type parameter, or NULL if 253313481Sgiacomo.travaglini@arm.com// this is not a typed or a type-parameterized test. 253413481Sgiacomo.travaglini@arm.com// value_param: text representation of the test's value parameter, 253513481Sgiacomo.travaglini@arm.com// or NULL if this is not a value-parameterized test. 253613481Sgiacomo.travaglini@arm.com// code_location: code location where the test is defined 253713481Sgiacomo.travaglini@arm.com// fixture_class_id: ID of the test fixture class 253813481Sgiacomo.travaglini@arm.com// set_up_tc: pointer to the function that sets up the test case 253913481Sgiacomo.travaglini@arm.com// tear_down_tc: pointer to the function that tears down the test case 254013481Sgiacomo.travaglini@arm.com// factory: pointer to the factory that creates a test object. 254113481Sgiacomo.travaglini@arm.com// The newly created TestInfo instance will assume 254213481Sgiacomo.travaglini@arm.com// ownership of the factory object. 254313481Sgiacomo.travaglini@arm.comTestInfo* MakeAndRegisterTestInfo( 254413481Sgiacomo.travaglini@arm.com const char* test_case_name, 254513481Sgiacomo.travaglini@arm.com const char* name, 254613481Sgiacomo.travaglini@arm.com const char* type_param, 254713481Sgiacomo.travaglini@arm.com const char* value_param, 254813481Sgiacomo.travaglini@arm.com CodeLocation code_location, 254913481Sgiacomo.travaglini@arm.com TypeId fixture_class_id, 255013481Sgiacomo.travaglini@arm.com SetUpTestCaseFunc set_up_tc, 255113481Sgiacomo.travaglini@arm.com TearDownTestCaseFunc tear_down_tc, 255213481Sgiacomo.travaglini@arm.com TestFactoryBase* factory) { 255313481Sgiacomo.travaglini@arm.com TestInfo* const test_info = 255413481Sgiacomo.travaglini@arm.com new TestInfo(test_case_name, name, type_param, value_param, 255513481Sgiacomo.travaglini@arm.com code_location, fixture_class_id, factory); 255613481Sgiacomo.travaglini@arm.com GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); 255713481Sgiacomo.travaglini@arm.com return test_info; 255813481Sgiacomo.travaglini@arm.com} 255913481Sgiacomo.travaglini@arm.com 256013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 256113481Sgiacomo.travaglini@arm.comvoid ReportInvalidTestCaseType(const char* test_case_name, 256213481Sgiacomo.travaglini@arm.com CodeLocation code_location) { 256313481Sgiacomo.travaglini@arm.com Message errors; 256413481Sgiacomo.travaglini@arm.com errors 256513481Sgiacomo.travaglini@arm.com << "Attempted redefinition of test case " << test_case_name << ".\n" 256613481Sgiacomo.travaglini@arm.com << "All tests in the same test case must use the same test fixture\n" 256713481Sgiacomo.travaglini@arm.com << "class. However, in test case " << test_case_name << ", you tried\n" 256813481Sgiacomo.travaglini@arm.com << "to define a test using a fixture class different from the one\n" 256913481Sgiacomo.travaglini@arm.com << "used earlier. This can happen if the two fixture classes are\n" 257013481Sgiacomo.travaglini@arm.com << "from different namespaces and have the same name. You should\n" 257113481Sgiacomo.travaglini@arm.com << "probably rename one of the classes to put the tests into different\n" 257213481Sgiacomo.travaglini@arm.com << "test cases."; 257313481Sgiacomo.travaglini@arm.com 257413481Sgiacomo.travaglini@arm.com fprintf(stderr, "%s %s", 257513481Sgiacomo.travaglini@arm.com FormatFileLocation(code_location.file.c_str(), 257613481Sgiacomo.travaglini@arm.com code_location.line).c_str(), 257713481Sgiacomo.travaglini@arm.com errors.GetString().c_str()); 257813481Sgiacomo.travaglini@arm.com} 257913481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PARAM_TEST 258013481Sgiacomo.travaglini@arm.com 258113481Sgiacomo.travaglini@arm.com} // namespace internal 258213481Sgiacomo.travaglini@arm.com 258313481Sgiacomo.travaglini@arm.comnamespace { 258413481Sgiacomo.travaglini@arm.com 258513481Sgiacomo.travaglini@arm.com// A predicate that checks the test name of a TestInfo against a known 258613481Sgiacomo.travaglini@arm.com// value. 258713481Sgiacomo.travaglini@arm.com// 258813481Sgiacomo.travaglini@arm.com// This is used for implementation of the TestCase class only. We put 258913481Sgiacomo.travaglini@arm.com// it in the anonymous namespace to prevent polluting the outer 259013481Sgiacomo.travaglini@arm.com// namespace. 259113481Sgiacomo.travaglini@arm.com// 259213481Sgiacomo.travaglini@arm.com// TestNameIs is copyable. 259313481Sgiacomo.travaglini@arm.comclass TestNameIs { 259413481Sgiacomo.travaglini@arm.com public: 259513481Sgiacomo.travaglini@arm.com // Constructor. 259613481Sgiacomo.travaglini@arm.com // 259713481Sgiacomo.travaglini@arm.com // TestNameIs has NO default constructor. 259813481Sgiacomo.travaglini@arm.com explicit TestNameIs(const char* name) 259913481Sgiacomo.travaglini@arm.com : name_(name) {} 260013481Sgiacomo.travaglini@arm.com 260113481Sgiacomo.travaglini@arm.com // Returns true iff the test name of test_info matches name_. 260213481Sgiacomo.travaglini@arm.com bool operator()(const TestInfo * test_info) const { 260313481Sgiacomo.travaglini@arm.com return test_info && test_info->name() == name_; 260413481Sgiacomo.travaglini@arm.com } 260513481Sgiacomo.travaglini@arm.com 260613481Sgiacomo.travaglini@arm.com private: 260713481Sgiacomo.travaglini@arm.com std::string name_; 260813481Sgiacomo.travaglini@arm.com}; 260913481Sgiacomo.travaglini@arm.com 261013481Sgiacomo.travaglini@arm.com} // namespace 261113481Sgiacomo.travaglini@arm.com 261213481Sgiacomo.travaglini@arm.comnamespace internal { 261313481Sgiacomo.travaglini@arm.com 261413481Sgiacomo.travaglini@arm.com// This method expands all parameterized tests registered with macros TEST_P 261513481Sgiacomo.travaglini@arm.com// and INSTANTIATE_TEST_CASE_P into regular tests and registers those. 261613481Sgiacomo.travaglini@arm.com// This will be done just once during the program runtime. 261713481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::RegisterParameterizedTests() { 261813481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 261913481Sgiacomo.travaglini@arm.com if (!parameterized_tests_registered_) { 262013481Sgiacomo.travaglini@arm.com parameterized_test_registry_.RegisterTests(); 262113481Sgiacomo.travaglini@arm.com parameterized_tests_registered_ = true; 262213481Sgiacomo.travaglini@arm.com } 262313481Sgiacomo.travaglini@arm.com#endif 262413481Sgiacomo.travaglini@arm.com} 262513481Sgiacomo.travaglini@arm.com 262613481Sgiacomo.travaglini@arm.com} // namespace internal 262713481Sgiacomo.travaglini@arm.com 262813481Sgiacomo.travaglini@arm.com// Creates the test object, runs it, records its result, and then 262913481Sgiacomo.travaglini@arm.com// deletes it. 263013481Sgiacomo.travaglini@arm.comvoid TestInfo::Run() { 263113481Sgiacomo.travaglini@arm.com if (!should_run_) return; 263213481Sgiacomo.travaglini@arm.com 263313481Sgiacomo.travaglini@arm.com // Tells UnitTest where to store test result. 263413481Sgiacomo.travaglini@arm.com internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 263513481Sgiacomo.travaglini@arm.com impl->set_current_test_info(this); 263613481Sgiacomo.travaglini@arm.com 263713481Sgiacomo.travaglini@arm.com TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 263813481Sgiacomo.travaglini@arm.com 263913481Sgiacomo.travaglini@arm.com // Notifies the unit test event listeners that a test is about to start. 264013481Sgiacomo.travaglini@arm.com repeater->OnTestStart(*this); 264113481Sgiacomo.travaglini@arm.com 264213481Sgiacomo.travaglini@arm.com const TimeInMillis start = internal::GetTimeInMillis(); 264313481Sgiacomo.travaglini@arm.com 264413481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 264513481Sgiacomo.travaglini@arm.com 264613481Sgiacomo.travaglini@arm.com // Creates the test object. 264713481Sgiacomo.travaglini@arm.com Test* const test = internal::HandleExceptionsInMethodIfSupported( 264813481Sgiacomo.travaglini@arm.com factory_, &internal::TestFactoryBase::CreateTest, 264913481Sgiacomo.travaglini@arm.com "the test fixture's constructor"); 265013481Sgiacomo.travaglini@arm.com 265113481Sgiacomo.travaglini@arm.com // Runs the test only if the test object was created and its 265213481Sgiacomo.travaglini@arm.com // constructor didn't generate a fatal failure. 265313481Sgiacomo.travaglini@arm.com if ((test != NULL) && !Test::HasFatalFailure()) { 265413481Sgiacomo.travaglini@arm.com // This doesn't throw as all user code that can throw are wrapped into 265513481Sgiacomo.travaglini@arm.com // exception handling code. 265613481Sgiacomo.travaglini@arm.com test->Run(); 265713481Sgiacomo.travaglini@arm.com } 265813481Sgiacomo.travaglini@arm.com 265913481Sgiacomo.travaglini@arm.com // Deletes the test object. 266013481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 266113481Sgiacomo.travaglini@arm.com internal::HandleExceptionsInMethodIfSupported( 266213481Sgiacomo.travaglini@arm.com test, &Test::DeleteSelf_, "the test fixture's destructor"); 266313481Sgiacomo.travaglini@arm.com 266413481Sgiacomo.travaglini@arm.com result_.set_elapsed_time(internal::GetTimeInMillis() - start); 266513481Sgiacomo.travaglini@arm.com 266613481Sgiacomo.travaglini@arm.com // Notifies the unit test event listener that a test has just finished. 266713481Sgiacomo.travaglini@arm.com repeater->OnTestEnd(*this); 266813481Sgiacomo.travaglini@arm.com 266913481Sgiacomo.travaglini@arm.com // Tells UnitTest to stop associating assertion results to this 267013481Sgiacomo.travaglini@arm.com // test. 267113481Sgiacomo.travaglini@arm.com impl->set_current_test_info(NULL); 267213481Sgiacomo.travaglini@arm.com} 267313481Sgiacomo.travaglini@arm.com 267413481Sgiacomo.travaglini@arm.com// class TestCase 267513481Sgiacomo.travaglini@arm.com 267613481Sgiacomo.travaglini@arm.com// Gets the number of successful tests in this test case. 267713481Sgiacomo.travaglini@arm.comint TestCase::successful_test_count() const { 267813481Sgiacomo.travaglini@arm.com return CountIf(test_info_list_, TestPassed); 267913481Sgiacomo.travaglini@arm.com} 268013481Sgiacomo.travaglini@arm.com 268113481Sgiacomo.travaglini@arm.com// Gets the number of failed tests in this test case. 268213481Sgiacomo.travaglini@arm.comint TestCase::failed_test_count() const { 268313481Sgiacomo.travaglini@arm.com return CountIf(test_info_list_, TestFailed); 268413481Sgiacomo.travaglini@arm.com} 268513481Sgiacomo.travaglini@arm.com 268613481Sgiacomo.travaglini@arm.com// Gets the number of disabled tests that will be reported in the XML report. 268713481Sgiacomo.travaglini@arm.comint TestCase::reportable_disabled_test_count() const { 268813481Sgiacomo.travaglini@arm.com return CountIf(test_info_list_, TestReportableDisabled); 268913481Sgiacomo.travaglini@arm.com} 269013481Sgiacomo.travaglini@arm.com 269113481Sgiacomo.travaglini@arm.com// Gets the number of disabled tests in this test case. 269213481Sgiacomo.travaglini@arm.comint TestCase::disabled_test_count() const { 269313481Sgiacomo.travaglini@arm.com return CountIf(test_info_list_, TestDisabled); 269413481Sgiacomo.travaglini@arm.com} 269513481Sgiacomo.travaglini@arm.com 269613481Sgiacomo.travaglini@arm.com// Gets the number of tests to be printed in the XML report. 269713481Sgiacomo.travaglini@arm.comint TestCase::reportable_test_count() const { 269813481Sgiacomo.travaglini@arm.com return CountIf(test_info_list_, TestReportable); 269913481Sgiacomo.travaglini@arm.com} 270013481Sgiacomo.travaglini@arm.com 270113481Sgiacomo.travaglini@arm.com// Get the number of tests in this test case that should run. 270213481Sgiacomo.travaglini@arm.comint TestCase::test_to_run_count() const { 270313481Sgiacomo.travaglini@arm.com return CountIf(test_info_list_, ShouldRunTest); 270413481Sgiacomo.travaglini@arm.com} 270513481Sgiacomo.travaglini@arm.com 270613481Sgiacomo.travaglini@arm.com// Gets the number of all tests. 270713481Sgiacomo.travaglini@arm.comint TestCase::total_test_count() const { 270813481Sgiacomo.travaglini@arm.com return static_cast<int>(test_info_list_.size()); 270913481Sgiacomo.travaglini@arm.com} 271013481Sgiacomo.travaglini@arm.com 271113481Sgiacomo.travaglini@arm.com// Creates a TestCase with the given name. 271213481Sgiacomo.travaglini@arm.com// 271313481Sgiacomo.travaglini@arm.com// Arguments: 271413481Sgiacomo.travaglini@arm.com// 271513481Sgiacomo.travaglini@arm.com// name: name of the test case 271613481Sgiacomo.travaglini@arm.com// a_type_param: the name of the test case's type parameter, or NULL if 271713481Sgiacomo.travaglini@arm.com// this is not a typed or a type-parameterized test case. 271813481Sgiacomo.travaglini@arm.com// set_up_tc: pointer to the function that sets up the test case 271913481Sgiacomo.travaglini@arm.com// tear_down_tc: pointer to the function that tears down the test case 272013481Sgiacomo.travaglini@arm.comTestCase::TestCase(const char* a_name, const char* a_type_param, 272113481Sgiacomo.travaglini@arm.com Test::SetUpTestCaseFunc set_up_tc, 272213481Sgiacomo.travaglini@arm.com Test::TearDownTestCaseFunc tear_down_tc) 272313481Sgiacomo.travaglini@arm.com : name_(a_name), 272413481Sgiacomo.travaglini@arm.com type_param_(a_type_param ? new std::string(a_type_param) : NULL), 272513481Sgiacomo.travaglini@arm.com set_up_tc_(set_up_tc), 272613481Sgiacomo.travaglini@arm.com tear_down_tc_(tear_down_tc), 272713481Sgiacomo.travaglini@arm.com should_run_(false), 272813481Sgiacomo.travaglini@arm.com elapsed_time_(0) { 272913481Sgiacomo.travaglini@arm.com} 273013481Sgiacomo.travaglini@arm.com 273113481Sgiacomo.travaglini@arm.com// Destructor of TestCase. 273213481Sgiacomo.travaglini@arm.comTestCase::~TestCase() { 273313481Sgiacomo.travaglini@arm.com // Deletes every Test in the collection. 273413481Sgiacomo.travaglini@arm.com ForEach(test_info_list_, internal::Delete<TestInfo>); 273513481Sgiacomo.travaglini@arm.com} 273613481Sgiacomo.travaglini@arm.com 273713481Sgiacomo.travaglini@arm.com// Returns the i-th test among all the tests. i can range from 0 to 273813481Sgiacomo.travaglini@arm.com// total_test_count() - 1. If i is not in that range, returns NULL. 273913481Sgiacomo.travaglini@arm.comconst TestInfo* TestCase::GetTestInfo(int i) const { 274013481Sgiacomo.travaglini@arm.com const int index = GetElementOr(test_indices_, i, -1); 274113481Sgiacomo.travaglini@arm.com return index < 0 ? NULL : test_info_list_[index]; 274213481Sgiacomo.travaglini@arm.com} 274313481Sgiacomo.travaglini@arm.com 274413481Sgiacomo.travaglini@arm.com// Returns the i-th test among all the tests. i can range from 0 to 274513481Sgiacomo.travaglini@arm.com// total_test_count() - 1. If i is not in that range, returns NULL. 274613481Sgiacomo.travaglini@arm.comTestInfo* TestCase::GetMutableTestInfo(int i) { 274713481Sgiacomo.travaglini@arm.com const int index = GetElementOr(test_indices_, i, -1); 274813481Sgiacomo.travaglini@arm.com return index < 0 ? NULL : test_info_list_[index]; 274913481Sgiacomo.travaglini@arm.com} 275013481Sgiacomo.travaglini@arm.com 275113481Sgiacomo.travaglini@arm.com// Adds a test to this test case. Will delete the test upon 275213481Sgiacomo.travaglini@arm.com// destruction of the TestCase object. 275313481Sgiacomo.travaglini@arm.comvoid TestCase::AddTestInfo(TestInfo * test_info) { 275413481Sgiacomo.travaglini@arm.com test_info_list_.push_back(test_info); 275513481Sgiacomo.travaglini@arm.com test_indices_.push_back(static_cast<int>(test_indices_.size())); 275613481Sgiacomo.travaglini@arm.com} 275713481Sgiacomo.travaglini@arm.com 275813481Sgiacomo.travaglini@arm.com// Runs every test in this TestCase. 275913481Sgiacomo.travaglini@arm.comvoid TestCase::Run() { 276013481Sgiacomo.travaglini@arm.com if (!should_run_) return; 276113481Sgiacomo.travaglini@arm.com 276213481Sgiacomo.travaglini@arm.com internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 276313481Sgiacomo.travaglini@arm.com impl->set_current_test_case(this); 276413481Sgiacomo.travaglini@arm.com 276513481Sgiacomo.travaglini@arm.com TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 276613481Sgiacomo.travaglini@arm.com 276713481Sgiacomo.travaglini@arm.com repeater->OnTestCaseStart(*this); 276813481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 276913481Sgiacomo.travaglini@arm.com internal::HandleExceptionsInMethodIfSupported( 277013481Sgiacomo.travaglini@arm.com this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); 277113481Sgiacomo.travaglini@arm.com 277213481Sgiacomo.travaglini@arm.com const internal::TimeInMillis start = internal::GetTimeInMillis(); 277313481Sgiacomo.travaglini@arm.com for (int i = 0; i < total_test_count(); i++) { 277413481Sgiacomo.travaglini@arm.com GetMutableTestInfo(i)->Run(); 277513481Sgiacomo.travaglini@arm.com } 277613481Sgiacomo.travaglini@arm.com elapsed_time_ = internal::GetTimeInMillis() - start; 277713481Sgiacomo.travaglini@arm.com 277813481Sgiacomo.travaglini@arm.com impl->os_stack_trace_getter()->UponLeavingGTest(); 277913481Sgiacomo.travaglini@arm.com internal::HandleExceptionsInMethodIfSupported( 278013481Sgiacomo.travaglini@arm.com this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); 278113481Sgiacomo.travaglini@arm.com 278213481Sgiacomo.travaglini@arm.com repeater->OnTestCaseEnd(*this); 278313481Sgiacomo.travaglini@arm.com impl->set_current_test_case(NULL); 278413481Sgiacomo.travaglini@arm.com} 278513481Sgiacomo.travaglini@arm.com 278613481Sgiacomo.travaglini@arm.com// Clears the results of all tests in this test case. 278713481Sgiacomo.travaglini@arm.comvoid TestCase::ClearResult() { 278813481Sgiacomo.travaglini@arm.com ad_hoc_test_result_.Clear(); 278913481Sgiacomo.travaglini@arm.com ForEach(test_info_list_, TestInfo::ClearTestResult); 279013481Sgiacomo.travaglini@arm.com} 279113481Sgiacomo.travaglini@arm.com 279213481Sgiacomo.travaglini@arm.com// Shuffles the tests in this test case. 279313481Sgiacomo.travaglini@arm.comvoid TestCase::ShuffleTests(internal::Random* random) { 279413481Sgiacomo.travaglini@arm.com Shuffle(random, &test_indices_); 279513481Sgiacomo.travaglini@arm.com} 279613481Sgiacomo.travaglini@arm.com 279713481Sgiacomo.travaglini@arm.com// Restores the test order to before the first shuffle. 279813481Sgiacomo.travaglini@arm.comvoid TestCase::UnshuffleTests() { 279913481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < test_indices_.size(); i++) { 280013481Sgiacomo.travaglini@arm.com test_indices_[i] = static_cast<int>(i); 280113481Sgiacomo.travaglini@arm.com } 280213481Sgiacomo.travaglini@arm.com} 280313481Sgiacomo.travaglini@arm.com 280413481Sgiacomo.travaglini@arm.com// Formats a countable noun. Depending on its quantity, either the 280513481Sgiacomo.travaglini@arm.com// singular form or the plural form is used. e.g. 280613481Sgiacomo.travaglini@arm.com// 280713481Sgiacomo.travaglini@arm.com// FormatCountableNoun(1, "formula", "formuli") returns "1 formula". 280813481Sgiacomo.travaglini@arm.com// FormatCountableNoun(5, "book", "books") returns "5 books". 280913481Sgiacomo.travaglini@arm.comstatic std::string FormatCountableNoun(int count, 281013481Sgiacomo.travaglini@arm.com const char * singular_form, 281113481Sgiacomo.travaglini@arm.com const char * plural_form) { 281213481Sgiacomo.travaglini@arm.com return internal::StreamableToString(count) + " " + 281313481Sgiacomo.travaglini@arm.com (count == 1 ? singular_form : plural_form); 281413481Sgiacomo.travaglini@arm.com} 281513481Sgiacomo.travaglini@arm.com 281613481Sgiacomo.travaglini@arm.com// Formats the count of tests. 281713481Sgiacomo.travaglini@arm.comstatic std::string FormatTestCount(int test_count) { 281813481Sgiacomo.travaglini@arm.com return FormatCountableNoun(test_count, "test", "tests"); 281913481Sgiacomo.travaglini@arm.com} 282013481Sgiacomo.travaglini@arm.com 282113481Sgiacomo.travaglini@arm.com// Formats the count of test cases. 282213481Sgiacomo.travaglini@arm.comstatic std::string FormatTestCaseCount(int test_case_count) { 282313481Sgiacomo.travaglini@arm.com return FormatCountableNoun(test_case_count, "test case", "test cases"); 282413481Sgiacomo.travaglini@arm.com} 282513481Sgiacomo.travaglini@arm.com 282613481Sgiacomo.travaglini@arm.com// Converts a TestPartResult::Type enum to human-friendly string 282713481Sgiacomo.travaglini@arm.com// representation. Both kNonFatalFailure and kFatalFailure are translated 282813481Sgiacomo.travaglini@arm.com// to "Failure", as the user usually doesn't care about the difference 282913481Sgiacomo.travaglini@arm.com// between the two when viewing the test result. 283013481Sgiacomo.travaglini@arm.comstatic const char * TestPartResultTypeToString(TestPartResult::Type type) { 283113481Sgiacomo.travaglini@arm.com switch (type) { 283213481Sgiacomo.travaglini@arm.com case TestPartResult::kSuccess: 283313481Sgiacomo.travaglini@arm.com return "Success"; 283413481Sgiacomo.travaglini@arm.com 283513481Sgiacomo.travaglini@arm.com case TestPartResult::kNonFatalFailure: 283613481Sgiacomo.travaglini@arm.com case TestPartResult::kFatalFailure: 283713481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER 283813481Sgiacomo.travaglini@arm.com return "error: "; 283913481Sgiacomo.travaglini@arm.com#else 284013481Sgiacomo.travaglini@arm.com return "Failure\n"; 284113481Sgiacomo.travaglini@arm.com#endif 284213481Sgiacomo.travaglini@arm.com default: 284313481Sgiacomo.travaglini@arm.com return "Unknown result type"; 284413481Sgiacomo.travaglini@arm.com } 284513481Sgiacomo.travaglini@arm.com} 284613481Sgiacomo.travaglini@arm.com 284713481Sgiacomo.travaglini@arm.comnamespace internal { 284813481Sgiacomo.travaglini@arm.com 284913481Sgiacomo.travaglini@arm.com// Prints a TestPartResult to an std::string. 285013481Sgiacomo.travaglini@arm.comstatic std::string PrintTestPartResultToString( 285113481Sgiacomo.travaglini@arm.com const TestPartResult& test_part_result) { 285213481Sgiacomo.travaglini@arm.com return (Message() 285313481Sgiacomo.travaglini@arm.com << internal::FormatFileLocation(test_part_result.file_name(), 285413481Sgiacomo.travaglini@arm.com test_part_result.line_number()) 285513481Sgiacomo.travaglini@arm.com << " " << TestPartResultTypeToString(test_part_result.type()) 285613481Sgiacomo.travaglini@arm.com << test_part_result.message()).GetString(); 285713481Sgiacomo.travaglini@arm.com} 285813481Sgiacomo.travaglini@arm.com 285913481Sgiacomo.travaglini@arm.com// Prints a TestPartResult. 286013481Sgiacomo.travaglini@arm.comstatic void PrintTestPartResult(const TestPartResult& test_part_result) { 286113481Sgiacomo.travaglini@arm.com const std::string& result = 286213481Sgiacomo.travaglini@arm.com PrintTestPartResultToString(test_part_result); 286313481Sgiacomo.travaglini@arm.com printf("%s\n", result.c_str()); 286413481Sgiacomo.travaglini@arm.com fflush(stdout); 286513481Sgiacomo.travaglini@arm.com // If the test program runs in Visual Studio or a debugger, the 286613481Sgiacomo.travaglini@arm.com // following statements add the test part result message to the Output 286713481Sgiacomo.travaglini@arm.com // window such that the user can double-click on it to jump to the 286813481Sgiacomo.travaglini@arm.com // corresponding source code location; otherwise they do nothing. 286913481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 287013481Sgiacomo.travaglini@arm.com // We don't call OutputDebugString*() on Windows Mobile, as printing 287113481Sgiacomo.travaglini@arm.com // to stdout is done by OutputDebugString() there already - we don't 287213481Sgiacomo.travaglini@arm.com // want the same message printed twice. 287313481Sgiacomo.travaglini@arm.com ::OutputDebugStringA(result.c_str()); 287413481Sgiacomo.travaglini@arm.com ::OutputDebugStringA("\n"); 287513481Sgiacomo.travaglini@arm.com#endif 287613481Sgiacomo.travaglini@arm.com} 287713481Sgiacomo.travaglini@arm.com 287813481Sgiacomo.travaglini@arm.com// class PrettyUnitTestResultPrinter 287913481Sgiacomo.travaglini@arm.com 288013481Sgiacomo.travaglini@arm.comenum GTestColor { 288113481Sgiacomo.travaglini@arm.com COLOR_DEFAULT, 288213481Sgiacomo.travaglini@arm.com COLOR_RED, 288313481Sgiacomo.travaglini@arm.com COLOR_GREEN, 288413481Sgiacomo.travaglini@arm.com COLOR_YELLOW 288513481Sgiacomo.travaglini@arm.com}; 288613481Sgiacomo.travaglini@arm.com 288713481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \ 288813481Sgiacomo.travaglini@arm.com !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 288913481Sgiacomo.travaglini@arm.com 289013481Sgiacomo.travaglini@arm.com// Returns the character attribute for the given color. 289113481Sgiacomo.travaglini@arm.comWORD GetColorAttribute(GTestColor color) { 289213481Sgiacomo.travaglini@arm.com switch (color) { 289313481Sgiacomo.travaglini@arm.com case COLOR_RED: return FOREGROUND_RED; 289413481Sgiacomo.travaglini@arm.com case COLOR_GREEN: return FOREGROUND_GREEN; 289513481Sgiacomo.travaglini@arm.com case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; 289613481Sgiacomo.travaglini@arm.com default: return 0; 289713481Sgiacomo.travaglini@arm.com } 289813481Sgiacomo.travaglini@arm.com} 289913481Sgiacomo.travaglini@arm.com 290013481Sgiacomo.travaglini@arm.com#else 290113481Sgiacomo.travaglini@arm.com 290213481Sgiacomo.travaglini@arm.com// Returns the ANSI color code for the given color. COLOR_DEFAULT is 290313481Sgiacomo.travaglini@arm.com// an invalid input. 290413481Sgiacomo.travaglini@arm.comconst char* GetAnsiColorCode(GTestColor color) { 290513481Sgiacomo.travaglini@arm.com switch (color) { 290613481Sgiacomo.travaglini@arm.com case COLOR_RED: return "1"; 290713481Sgiacomo.travaglini@arm.com case COLOR_GREEN: return "2"; 290813481Sgiacomo.travaglini@arm.com case COLOR_YELLOW: return "3"; 290913481Sgiacomo.travaglini@arm.com default: return NULL; 291013481Sgiacomo.travaglini@arm.com }; 291113481Sgiacomo.travaglini@arm.com} 291213481Sgiacomo.travaglini@arm.com 291313481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 291413481Sgiacomo.travaglini@arm.com 291513481Sgiacomo.travaglini@arm.com// Returns true iff Google Test should use colors in the output. 291613481Sgiacomo.travaglini@arm.combool ShouldUseColor(bool stdout_is_tty) { 291713481Sgiacomo.travaglini@arm.com const char* const gtest_color = GTEST_FLAG(color).c_str(); 291813481Sgiacomo.travaglini@arm.com 291913481Sgiacomo.travaglini@arm.com if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { 292013481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 292113481Sgiacomo.travaglini@arm.com // On Windows the TERM variable is usually not set, but the 292213481Sgiacomo.travaglini@arm.com // console there does support colors. 292313481Sgiacomo.travaglini@arm.com return stdout_is_tty; 292413481Sgiacomo.travaglini@arm.com#else 292513481Sgiacomo.travaglini@arm.com // On non-Windows platforms, we rely on the TERM variable. 292613481Sgiacomo.travaglini@arm.com const char* const term = posix::GetEnv("TERM"); 292713481Sgiacomo.travaglini@arm.com const bool term_supports_color = 292813481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "xterm") || 292913481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "xterm-color") || 293013481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "xterm-256color") || 293113481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "screen") || 293213481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "screen-256color") || 293313481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "tmux") || 293413481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "tmux-256color") || 293513481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "rxvt-unicode") || 293613481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "rxvt-unicode-256color") || 293713481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "linux") || 293813481Sgiacomo.travaglini@arm.com String::CStringEquals(term, "cygwin"); 293913481Sgiacomo.travaglini@arm.com return stdout_is_tty && term_supports_color; 294013481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 294113481Sgiacomo.travaglini@arm.com } 294213481Sgiacomo.travaglini@arm.com 294313481Sgiacomo.travaglini@arm.com return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || 294413481Sgiacomo.travaglini@arm.com String::CaseInsensitiveCStringEquals(gtest_color, "true") || 294513481Sgiacomo.travaglini@arm.com String::CaseInsensitiveCStringEquals(gtest_color, "t") || 294613481Sgiacomo.travaglini@arm.com String::CStringEquals(gtest_color, "1"); 294713481Sgiacomo.travaglini@arm.com // We take "yes", "true", "t", and "1" as meaning "yes". If the 294813481Sgiacomo.travaglini@arm.com // value is neither one of these nor "auto", we treat it as "no" to 294913481Sgiacomo.travaglini@arm.com // be conservative. 295013481Sgiacomo.travaglini@arm.com} 295113481Sgiacomo.travaglini@arm.com 295213481Sgiacomo.travaglini@arm.com// Helpers for printing colored strings to stdout. Note that on Windows, we 295313481Sgiacomo.travaglini@arm.com// cannot simply emit special characters and have the terminal change colors. 295413481Sgiacomo.travaglini@arm.com// This routine must actually emit the characters rather than return a string 295513481Sgiacomo.travaglini@arm.com// that would be colored when printed, as can be done on Linux. 295613481Sgiacomo.travaglini@arm.comvoid ColoredPrintf(GTestColor color, const char* fmt, ...) { 295713481Sgiacomo.travaglini@arm.com va_list args; 295813481Sgiacomo.travaglini@arm.com va_start(args, fmt); 295913481Sgiacomo.travaglini@arm.com 296013481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \ 296113481Sgiacomo.travaglini@arm.com GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT 296213481Sgiacomo.travaglini@arm.com const bool use_color = AlwaysFalse(); 296313481Sgiacomo.travaglini@arm.com#else 296413481Sgiacomo.travaglini@arm.com static const bool in_color_mode = 296513481Sgiacomo.travaglini@arm.com ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); 296613481Sgiacomo.travaglini@arm.com const bool use_color = in_color_mode && (color != COLOR_DEFAULT); 296713481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS 296813481Sgiacomo.travaglini@arm.com // The '!= 0' comparison is necessary to satisfy MSVC 7.1. 296913481Sgiacomo.travaglini@arm.com 297013481Sgiacomo.travaglini@arm.com if (!use_color) { 297113481Sgiacomo.travaglini@arm.com vprintf(fmt, args); 297213481Sgiacomo.travaglini@arm.com va_end(args); 297313481Sgiacomo.travaglini@arm.com return; 297413481Sgiacomo.travaglini@arm.com } 297513481Sgiacomo.travaglini@arm.com 297613481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \ 297713481Sgiacomo.travaglini@arm.com !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 297813481Sgiacomo.travaglini@arm.com const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); 297913481Sgiacomo.travaglini@arm.com 298013481Sgiacomo.travaglini@arm.com // Gets the current text color. 298113481Sgiacomo.travaglini@arm.com CONSOLE_SCREEN_BUFFER_INFO buffer_info; 298213481Sgiacomo.travaglini@arm.com GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); 298313481Sgiacomo.travaglini@arm.com const WORD old_color_attrs = buffer_info.wAttributes; 298413481Sgiacomo.travaglini@arm.com 298513481Sgiacomo.travaglini@arm.com // We need to flush the stream buffers into the console before each 298613481Sgiacomo.travaglini@arm.com // SetConsoleTextAttribute call lest it affect the text that is already 298713481Sgiacomo.travaglini@arm.com // printed but has not yet reached the console. 298813481Sgiacomo.travaglini@arm.com fflush(stdout); 298913481Sgiacomo.travaglini@arm.com SetConsoleTextAttribute(stdout_handle, 299013481Sgiacomo.travaglini@arm.com GetColorAttribute(color) | FOREGROUND_INTENSITY); 299113481Sgiacomo.travaglini@arm.com vprintf(fmt, args); 299213481Sgiacomo.travaglini@arm.com 299313481Sgiacomo.travaglini@arm.com fflush(stdout); 299413481Sgiacomo.travaglini@arm.com // Restores the text color. 299513481Sgiacomo.travaglini@arm.com SetConsoleTextAttribute(stdout_handle, old_color_attrs); 299613481Sgiacomo.travaglini@arm.com#else 299713481Sgiacomo.travaglini@arm.com printf("\033[0;3%sm", GetAnsiColorCode(color)); 299813481Sgiacomo.travaglini@arm.com vprintf(fmt, args); 299913481Sgiacomo.travaglini@arm.com printf("\033[m"); // Resets the terminal to default. 300013481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 300113481Sgiacomo.travaglini@arm.com va_end(args); 300213481Sgiacomo.travaglini@arm.com} 300313481Sgiacomo.travaglini@arm.com 300413481Sgiacomo.travaglini@arm.com// Text printed in Google Test's text output and --gunit_list_tests 300513481Sgiacomo.travaglini@arm.com// output to label the type parameter and value parameter for a test. 300613481Sgiacomo.travaglini@arm.comstatic const char kTypeParamLabel[] = "TypeParam"; 300713481Sgiacomo.travaglini@arm.comstatic const char kValueParamLabel[] = "GetParam()"; 300813481Sgiacomo.travaglini@arm.com 300913481Sgiacomo.travaglini@arm.comvoid PrintFullTestCommentIfPresent(const TestInfo& test_info) { 301013481Sgiacomo.travaglini@arm.com const char* const type_param = test_info.type_param(); 301113481Sgiacomo.travaglini@arm.com const char* const value_param = test_info.value_param(); 301213481Sgiacomo.travaglini@arm.com 301313481Sgiacomo.travaglini@arm.com if (type_param != NULL || value_param != NULL) { 301413481Sgiacomo.travaglini@arm.com printf(", where "); 301513481Sgiacomo.travaglini@arm.com if (type_param != NULL) { 301613481Sgiacomo.travaglini@arm.com printf("%s = %s", kTypeParamLabel, type_param); 301713481Sgiacomo.travaglini@arm.com if (value_param != NULL) 301813481Sgiacomo.travaglini@arm.com printf(" and "); 301913481Sgiacomo.travaglini@arm.com } 302013481Sgiacomo.travaglini@arm.com if (value_param != NULL) { 302113481Sgiacomo.travaglini@arm.com printf("%s = %s", kValueParamLabel, value_param); 302213481Sgiacomo.travaglini@arm.com } 302313481Sgiacomo.travaglini@arm.com } 302413481Sgiacomo.travaglini@arm.com} 302513481Sgiacomo.travaglini@arm.com 302613481Sgiacomo.travaglini@arm.com// This class implements the TestEventListener interface. 302713481Sgiacomo.travaglini@arm.com// 302813481Sgiacomo.travaglini@arm.com// Class PrettyUnitTestResultPrinter is copyable. 302913481Sgiacomo.travaglini@arm.comclass PrettyUnitTestResultPrinter : public TestEventListener { 303013481Sgiacomo.travaglini@arm.com public: 303113481Sgiacomo.travaglini@arm.com PrettyUnitTestResultPrinter() {} 303213481Sgiacomo.travaglini@arm.com static void PrintTestName(const char * test_case, const char * test) { 303313481Sgiacomo.travaglini@arm.com printf("%s.%s", test_case, test); 303413481Sgiacomo.travaglini@arm.com } 303513481Sgiacomo.travaglini@arm.com 303613481Sgiacomo.travaglini@arm.com // The following methods override what's in the TestEventListener class. 303713481Sgiacomo.travaglini@arm.com virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} 303813481Sgiacomo.travaglini@arm.com virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); 303913481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); 304013481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} 304113481Sgiacomo.travaglini@arm.com virtual void OnTestCaseStart(const TestCase& test_case); 304213481Sgiacomo.travaglini@arm.com virtual void OnTestStart(const TestInfo& test_info); 304313481Sgiacomo.travaglini@arm.com virtual void OnTestPartResult(const TestPartResult& result); 304413481Sgiacomo.travaglini@arm.com virtual void OnTestEnd(const TestInfo& test_info); 304513481Sgiacomo.travaglini@arm.com virtual void OnTestCaseEnd(const TestCase& test_case); 304613481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); 304713481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} 304813481Sgiacomo.travaglini@arm.com virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 304913481Sgiacomo.travaglini@arm.com virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} 305013481Sgiacomo.travaglini@arm.com 305113481Sgiacomo.travaglini@arm.com private: 305213481Sgiacomo.travaglini@arm.com static void PrintFailedTests(const UnitTest& unit_test); 305313481Sgiacomo.travaglini@arm.com}; 305413481Sgiacomo.travaglini@arm.com 305513481Sgiacomo.travaglini@arm.com // Fired before each iteration of tests starts. 305613481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestIterationStart( 305713481Sgiacomo.travaglini@arm.com const UnitTest& unit_test, int iteration) { 305813481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(repeat) != 1) 305913481Sgiacomo.travaglini@arm.com printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); 306013481Sgiacomo.travaglini@arm.com 306113481Sgiacomo.travaglini@arm.com const char* const filter = GTEST_FLAG(filter).c_str(); 306213481Sgiacomo.travaglini@arm.com 306313481Sgiacomo.travaglini@arm.com // Prints the filter if it's not *. This reminds the user that some 306413481Sgiacomo.travaglini@arm.com // tests may be skipped. 306513481Sgiacomo.travaglini@arm.com if (!String::CStringEquals(filter, kUniversalFilter)) { 306613481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_YELLOW, 306713481Sgiacomo.travaglini@arm.com "Note: %s filter = %s\n", GTEST_NAME_, filter); 306813481Sgiacomo.travaglini@arm.com } 306913481Sgiacomo.travaglini@arm.com 307013481Sgiacomo.travaglini@arm.com if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { 307113481Sgiacomo.travaglini@arm.com const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); 307213481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_YELLOW, 307313481Sgiacomo.travaglini@arm.com "Note: This is test shard %d of %s.\n", 307413481Sgiacomo.travaglini@arm.com static_cast<int>(shard_index) + 1, 307513481Sgiacomo.travaglini@arm.com internal::posix::GetEnv(kTestTotalShards)); 307613481Sgiacomo.travaglini@arm.com } 307713481Sgiacomo.travaglini@arm.com 307813481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(shuffle)) { 307913481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_YELLOW, 308013481Sgiacomo.travaglini@arm.com "Note: Randomizing tests' orders with a seed of %d .\n", 308113481Sgiacomo.travaglini@arm.com unit_test.random_seed()); 308213481Sgiacomo.travaglini@arm.com } 308313481Sgiacomo.travaglini@arm.com 308413481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[==========] "); 308513481Sgiacomo.travaglini@arm.com printf("Running %s from %s.\n", 308613481Sgiacomo.travaglini@arm.com FormatTestCount(unit_test.test_to_run_count()).c_str(), 308713481Sgiacomo.travaglini@arm.com FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); 308813481Sgiacomo.travaglini@arm.com fflush(stdout); 308913481Sgiacomo.travaglini@arm.com} 309013481Sgiacomo.travaglini@arm.com 309113481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( 309213481Sgiacomo.travaglini@arm.com const UnitTest& /*unit_test*/) { 309313481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[----------] "); 309413481Sgiacomo.travaglini@arm.com printf("Global test environment set-up.\n"); 309513481Sgiacomo.travaglini@arm.com fflush(stdout); 309613481Sgiacomo.travaglini@arm.com} 309713481Sgiacomo.travaglini@arm.com 309813481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { 309913481Sgiacomo.travaglini@arm.com const std::string counts = 310013481Sgiacomo.travaglini@arm.com FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 310113481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[----------] "); 310213481Sgiacomo.travaglini@arm.com printf("%s from %s", counts.c_str(), test_case.name()); 310313481Sgiacomo.travaglini@arm.com if (test_case.type_param() == NULL) { 310413481Sgiacomo.travaglini@arm.com printf("\n"); 310513481Sgiacomo.travaglini@arm.com } else { 310613481Sgiacomo.travaglini@arm.com printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); 310713481Sgiacomo.travaglini@arm.com } 310813481Sgiacomo.travaglini@arm.com fflush(stdout); 310913481Sgiacomo.travaglini@arm.com} 311013481Sgiacomo.travaglini@arm.com 311113481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { 311213481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[ RUN ] "); 311313481Sgiacomo.travaglini@arm.com PrintTestName(test_info.test_case_name(), test_info.name()); 311413481Sgiacomo.travaglini@arm.com printf("\n"); 311513481Sgiacomo.travaglini@arm.com fflush(stdout); 311613481Sgiacomo.travaglini@arm.com} 311713481Sgiacomo.travaglini@arm.com 311813481Sgiacomo.travaglini@arm.com// Called after an assertion failure. 311913481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestPartResult( 312013481Sgiacomo.travaglini@arm.com const TestPartResult& result) { 312113481Sgiacomo.travaglini@arm.com // If the test part succeeded, we don't need to do anything. 312213481Sgiacomo.travaglini@arm.com if (result.type() == TestPartResult::kSuccess) 312313481Sgiacomo.travaglini@arm.com return; 312413481Sgiacomo.travaglini@arm.com 312513481Sgiacomo.travaglini@arm.com // Print failure message from the assertion (e.g. expected this and got that). 312613481Sgiacomo.travaglini@arm.com PrintTestPartResult(result); 312713481Sgiacomo.travaglini@arm.com fflush(stdout); 312813481Sgiacomo.travaglini@arm.com} 312913481Sgiacomo.travaglini@arm.com 313013481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { 313113481Sgiacomo.travaglini@arm.com if (test_info.result()->Passed()) { 313213481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[ OK ] "); 313313481Sgiacomo.travaglini@arm.com } else { 313413481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, "[ FAILED ] "); 313513481Sgiacomo.travaglini@arm.com } 313613481Sgiacomo.travaglini@arm.com PrintTestName(test_info.test_case_name(), test_info.name()); 313713481Sgiacomo.travaglini@arm.com if (test_info.result()->Failed()) 313813481Sgiacomo.travaglini@arm.com PrintFullTestCommentIfPresent(test_info); 313913481Sgiacomo.travaglini@arm.com 314013481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(print_time)) { 314113481Sgiacomo.travaglini@arm.com printf(" (%s ms)\n", internal::StreamableToString( 314213481Sgiacomo.travaglini@arm.com test_info.result()->elapsed_time()).c_str()); 314313481Sgiacomo.travaglini@arm.com } else { 314413481Sgiacomo.travaglini@arm.com printf("\n"); 314513481Sgiacomo.travaglini@arm.com } 314613481Sgiacomo.travaglini@arm.com fflush(stdout); 314713481Sgiacomo.travaglini@arm.com} 314813481Sgiacomo.travaglini@arm.com 314913481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { 315013481Sgiacomo.travaglini@arm.com if (!GTEST_FLAG(print_time)) return; 315113481Sgiacomo.travaglini@arm.com 315213481Sgiacomo.travaglini@arm.com const std::string counts = 315313481Sgiacomo.travaglini@arm.com FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 315413481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[----------] "); 315513481Sgiacomo.travaglini@arm.com printf("%s from %s (%s ms total)\n\n", 315613481Sgiacomo.travaglini@arm.com counts.c_str(), test_case.name(), 315713481Sgiacomo.travaglini@arm.com internal::StreamableToString(test_case.elapsed_time()).c_str()); 315813481Sgiacomo.travaglini@arm.com fflush(stdout); 315913481Sgiacomo.travaglini@arm.com} 316013481Sgiacomo.travaglini@arm.com 316113481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( 316213481Sgiacomo.travaglini@arm.com const UnitTest& /*unit_test*/) { 316313481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[----------] "); 316413481Sgiacomo.travaglini@arm.com printf("Global test environment tear-down\n"); 316513481Sgiacomo.travaglini@arm.com fflush(stdout); 316613481Sgiacomo.travaglini@arm.com} 316713481Sgiacomo.travaglini@arm.com 316813481Sgiacomo.travaglini@arm.com// Internal helper for printing the list of failed tests. 316913481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { 317013481Sgiacomo.travaglini@arm.com const int failed_test_count = unit_test.failed_test_count(); 317113481Sgiacomo.travaglini@arm.com if (failed_test_count == 0) { 317213481Sgiacomo.travaglini@arm.com return; 317313481Sgiacomo.travaglini@arm.com } 317413481Sgiacomo.travaglini@arm.com 317513481Sgiacomo.travaglini@arm.com for (int i = 0; i < unit_test.total_test_case_count(); ++i) { 317613481Sgiacomo.travaglini@arm.com const TestCase& test_case = *unit_test.GetTestCase(i); 317713481Sgiacomo.travaglini@arm.com if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { 317813481Sgiacomo.travaglini@arm.com continue; 317913481Sgiacomo.travaglini@arm.com } 318013481Sgiacomo.travaglini@arm.com for (int j = 0; j < test_case.total_test_count(); ++j) { 318113481Sgiacomo.travaglini@arm.com const TestInfo& test_info = *test_case.GetTestInfo(j); 318213481Sgiacomo.travaglini@arm.com if (!test_info.should_run() || test_info.result()->Passed()) { 318313481Sgiacomo.travaglini@arm.com continue; 318413481Sgiacomo.travaglini@arm.com } 318513481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, "[ FAILED ] "); 318613481Sgiacomo.travaglini@arm.com printf("%s.%s", test_case.name(), test_info.name()); 318713481Sgiacomo.travaglini@arm.com PrintFullTestCommentIfPresent(test_info); 318813481Sgiacomo.travaglini@arm.com printf("\n"); 318913481Sgiacomo.travaglini@arm.com } 319013481Sgiacomo.travaglini@arm.com } 319113481Sgiacomo.travaglini@arm.com} 319213481Sgiacomo.travaglini@arm.com 319313481Sgiacomo.travaglini@arm.comvoid PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 319413481Sgiacomo.travaglini@arm.com int /*iteration*/) { 319513481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[==========] "); 319613481Sgiacomo.travaglini@arm.com printf("%s from %s ran.", 319713481Sgiacomo.travaglini@arm.com FormatTestCount(unit_test.test_to_run_count()).c_str(), 319813481Sgiacomo.travaglini@arm.com FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); 319913481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(print_time)) { 320013481Sgiacomo.travaglini@arm.com printf(" (%s ms total)", 320113481Sgiacomo.travaglini@arm.com internal::StreamableToString(unit_test.elapsed_time()).c_str()); 320213481Sgiacomo.travaglini@arm.com } 320313481Sgiacomo.travaglini@arm.com printf("\n"); 320413481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); 320513481Sgiacomo.travaglini@arm.com printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); 320613481Sgiacomo.travaglini@arm.com 320713481Sgiacomo.travaglini@arm.com int num_failures = unit_test.failed_test_count(); 320813481Sgiacomo.travaglini@arm.com if (!unit_test.Passed()) { 320913481Sgiacomo.travaglini@arm.com const int failed_test_count = unit_test.failed_test_count(); 321013481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, "[ FAILED ] "); 321113481Sgiacomo.travaglini@arm.com printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); 321213481Sgiacomo.travaglini@arm.com PrintFailedTests(unit_test); 321313481Sgiacomo.travaglini@arm.com printf("\n%2d FAILED %s\n", num_failures, 321413481Sgiacomo.travaglini@arm.com num_failures == 1 ? "TEST" : "TESTS"); 321513481Sgiacomo.travaglini@arm.com } 321613481Sgiacomo.travaglini@arm.com 321713481Sgiacomo.travaglini@arm.com int num_disabled = unit_test.reportable_disabled_test_count(); 321813481Sgiacomo.travaglini@arm.com if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { 321913481Sgiacomo.travaglini@arm.com if (!num_failures) { 322013481Sgiacomo.travaglini@arm.com printf("\n"); // Add a spacer if no FAILURE banner is displayed. 322113481Sgiacomo.travaglini@arm.com } 322213481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_YELLOW, 322313481Sgiacomo.travaglini@arm.com " YOU HAVE %d DISABLED %s\n\n", 322413481Sgiacomo.travaglini@arm.com num_disabled, 322513481Sgiacomo.travaglini@arm.com num_disabled == 1 ? "TEST" : "TESTS"); 322613481Sgiacomo.travaglini@arm.com } 322713481Sgiacomo.travaglini@arm.com // Ensure that Google Test output is printed before, e.g., heapchecker output. 322813481Sgiacomo.travaglini@arm.com fflush(stdout); 322913481Sgiacomo.travaglini@arm.com} 323013481Sgiacomo.travaglini@arm.com 323113481Sgiacomo.travaglini@arm.com// End PrettyUnitTestResultPrinter 323213481Sgiacomo.travaglini@arm.com 323313481Sgiacomo.travaglini@arm.com// class TestEventRepeater 323413481Sgiacomo.travaglini@arm.com// 323513481Sgiacomo.travaglini@arm.com// This class forwards events to other event listeners. 323613481Sgiacomo.travaglini@arm.comclass TestEventRepeater : public TestEventListener { 323713481Sgiacomo.travaglini@arm.com public: 323813481Sgiacomo.travaglini@arm.com TestEventRepeater() : forwarding_enabled_(true) {} 323913481Sgiacomo.travaglini@arm.com virtual ~TestEventRepeater(); 324013481Sgiacomo.travaglini@arm.com void Append(TestEventListener *listener); 324113481Sgiacomo.travaglini@arm.com TestEventListener* Release(TestEventListener* listener); 324213481Sgiacomo.travaglini@arm.com 324313481Sgiacomo.travaglini@arm.com // Controls whether events will be forwarded to listeners_. Set to false 324413481Sgiacomo.travaglini@arm.com // in death test child processes. 324513481Sgiacomo.travaglini@arm.com bool forwarding_enabled() const { return forwarding_enabled_; } 324613481Sgiacomo.travaglini@arm.com void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } 324713481Sgiacomo.travaglini@arm.com 324813481Sgiacomo.travaglini@arm.com virtual void OnTestProgramStart(const UnitTest& unit_test); 324913481Sgiacomo.travaglini@arm.com virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); 325013481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); 325113481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); 325213481Sgiacomo.travaglini@arm.com virtual void OnTestCaseStart(const TestCase& test_case); 325313481Sgiacomo.travaglini@arm.com virtual void OnTestStart(const TestInfo& test_info); 325413481Sgiacomo.travaglini@arm.com virtual void OnTestPartResult(const TestPartResult& result); 325513481Sgiacomo.travaglini@arm.com virtual void OnTestEnd(const TestInfo& test_info); 325613481Sgiacomo.travaglini@arm.com virtual void OnTestCaseEnd(const TestCase& test_case); 325713481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); 325813481Sgiacomo.travaglini@arm.com virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); 325913481Sgiacomo.travaglini@arm.com virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 326013481Sgiacomo.travaglini@arm.com virtual void OnTestProgramEnd(const UnitTest& unit_test); 326113481Sgiacomo.travaglini@arm.com 326213481Sgiacomo.travaglini@arm.com private: 326313481Sgiacomo.travaglini@arm.com // Controls whether events will be forwarded to listeners_. Set to false 326413481Sgiacomo.travaglini@arm.com // in death test child processes. 326513481Sgiacomo.travaglini@arm.com bool forwarding_enabled_; 326613481Sgiacomo.travaglini@arm.com // The list of listeners that receive events. 326713481Sgiacomo.travaglini@arm.com std::vector<TestEventListener*> listeners_; 326813481Sgiacomo.travaglini@arm.com 326913481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); 327013481Sgiacomo.travaglini@arm.com}; 327113481Sgiacomo.travaglini@arm.com 327213481Sgiacomo.travaglini@arm.comTestEventRepeater::~TestEventRepeater() { 327313481Sgiacomo.travaglini@arm.com ForEach(listeners_, Delete<TestEventListener>); 327413481Sgiacomo.travaglini@arm.com} 327513481Sgiacomo.travaglini@arm.com 327613481Sgiacomo.travaglini@arm.comvoid TestEventRepeater::Append(TestEventListener *listener) { 327713481Sgiacomo.travaglini@arm.com listeners_.push_back(listener); 327813481Sgiacomo.travaglini@arm.com} 327913481Sgiacomo.travaglini@arm.com 328013481Sgiacomo.travaglini@arm.com// TODO(vladl@google.com): Factor the search functionality into Vector::Find. 328113481Sgiacomo.travaglini@arm.comTestEventListener* TestEventRepeater::Release(TestEventListener *listener) { 328213481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < listeners_.size(); ++i) { 328313481Sgiacomo.travaglini@arm.com if (listeners_[i] == listener) { 328413481Sgiacomo.travaglini@arm.com listeners_.erase(listeners_.begin() + i); 328513481Sgiacomo.travaglini@arm.com return listener; 328613481Sgiacomo.travaglini@arm.com } 328713481Sgiacomo.travaglini@arm.com } 328813481Sgiacomo.travaglini@arm.com 328913481Sgiacomo.travaglini@arm.com return NULL; 329013481Sgiacomo.travaglini@arm.com} 329113481Sgiacomo.travaglini@arm.com 329213481Sgiacomo.travaglini@arm.com// Since most methods are very similar, use macros to reduce boilerplate. 329313481Sgiacomo.travaglini@arm.com// This defines a member that forwards the call to all listeners. 329413481Sgiacomo.travaglini@arm.com#define GTEST_REPEATER_METHOD_(Name, Type) \ 329513481Sgiacomo.travaglini@arm.comvoid TestEventRepeater::Name(const Type& parameter) { \ 329613481Sgiacomo.travaglini@arm.com if (forwarding_enabled_) { \ 329713481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < listeners_.size(); i++) { \ 329813481Sgiacomo.travaglini@arm.com listeners_[i]->Name(parameter); \ 329913481Sgiacomo.travaglini@arm.com } \ 330013481Sgiacomo.travaglini@arm.com } \ 330113481Sgiacomo.travaglini@arm.com} 330213481Sgiacomo.travaglini@arm.com// This defines a member that forwards the call to all listeners in reverse 330313481Sgiacomo.travaglini@arm.com// order. 330413481Sgiacomo.travaglini@arm.com#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ 330513481Sgiacomo.travaglini@arm.comvoid TestEventRepeater::Name(const Type& parameter) { \ 330613481Sgiacomo.travaglini@arm.com if (forwarding_enabled_) { \ 330713481Sgiacomo.travaglini@arm.com for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \ 330813481Sgiacomo.travaglini@arm.com listeners_[i]->Name(parameter); \ 330913481Sgiacomo.travaglini@arm.com } \ 331013481Sgiacomo.travaglini@arm.com } \ 331113481Sgiacomo.travaglini@arm.com} 331213481Sgiacomo.travaglini@arm.com 331313481Sgiacomo.travaglini@arm.comGTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) 331413481Sgiacomo.travaglini@arm.comGTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) 331513481Sgiacomo.travaglini@arm.comGTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) 331613481Sgiacomo.travaglini@arm.comGTEST_REPEATER_METHOD_(OnTestStart, TestInfo) 331713481Sgiacomo.travaglini@arm.comGTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) 331813481Sgiacomo.travaglini@arm.comGTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) 331913481Sgiacomo.travaglini@arm.comGTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) 332013481Sgiacomo.travaglini@arm.comGTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) 332113481Sgiacomo.travaglini@arm.comGTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) 332213481Sgiacomo.travaglini@arm.comGTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) 332313481Sgiacomo.travaglini@arm.comGTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) 332413481Sgiacomo.travaglini@arm.com 332513481Sgiacomo.travaglini@arm.com#undef GTEST_REPEATER_METHOD_ 332613481Sgiacomo.travaglini@arm.com#undef GTEST_REVERSE_REPEATER_METHOD_ 332713481Sgiacomo.travaglini@arm.com 332813481Sgiacomo.travaglini@arm.comvoid TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, 332913481Sgiacomo.travaglini@arm.com int iteration) { 333013481Sgiacomo.travaglini@arm.com if (forwarding_enabled_) { 333113481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < listeners_.size(); i++) { 333213481Sgiacomo.travaglini@arm.com listeners_[i]->OnTestIterationStart(unit_test, iteration); 333313481Sgiacomo.travaglini@arm.com } 333413481Sgiacomo.travaglini@arm.com } 333513481Sgiacomo.travaglini@arm.com} 333613481Sgiacomo.travaglini@arm.com 333713481Sgiacomo.travaglini@arm.comvoid TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, 333813481Sgiacomo.travaglini@arm.com int iteration) { 333913481Sgiacomo.travaglini@arm.com if (forwarding_enabled_) { 334013481Sgiacomo.travaglini@arm.com for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { 334113481Sgiacomo.travaglini@arm.com listeners_[i]->OnTestIterationEnd(unit_test, iteration); 334213481Sgiacomo.travaglini@arm.com } 334313481Sgiacomo.travaglini@arm.com } 334413481Sgiacomo.travaglini@arm.com} 334513481Sgiacomo.travaglini@arm.com 334613481Sgiacomo.travaglini@arm.com// End TestEventRepeater 334713481Sgiacomo.travaglini@arm.com 334813481Sgiacomo.travaglini@arm.com// This class generates an XML output file. 334913481Sgiacomo.travaglini@arm.comclass XmlUnitTestResultPrinter : public EmptyTestEventListener { 335013481Sgiacomo.travaglini@arm.com public: 335113481Sgiacomo.travaglini@arm.com explicit XmlUnitTestResultPrinter(const char* output_file); 335213481Sgiacomo.travaglini@arm.com 335313481Sgiacomo.travaglini@arm.com virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); 335413481Sgiacomo.travaglini@arm.com 335513481Sgiacomo.travaglini@arm.com private: 335613481Sgiacomo.travaglini@arm.com // Is c a whitespace character that is normalized to a space character 335713481Sgiacomo.travaglini@arm.com // when it appears in an XML attribute value? 335813481Sgiacomo.travaglini@arm.com static bool IsNormalizableWhitespace(char c) { 335913481Sgiacomo.travaglini@arm.com return c == 0x9 || c == 0xA || c == 0xD; 336013481Sgiacomo.travaglini@arm.com } 336113481Sgiacomo.travaglini@arm.com 336213481Sgiacomo.travaglini@arm.com // May c appear in a well-formed XML document? 336313481Sgiacomo.travaglini@arm.com static bool IsValidXmlCharacter(char c) { 336413481Sgiacomo.travaglini@arm.com return IsNormalizableWhitespace(c) || c >= 0x20; 336513481Sgiacomo.travaglini@arm.com } 336613481Sgiacomo.travaglini@arm.com 336713481Sgiacomo.travaglini@arm.com // Returns an XML-escaped copy of the input string str. If 336813481Sgiacomo.travaglini@arm.com // is_attribute is true, the text is meant to appear as an attribute 336913481Sgiacomo.travaglini@arm.com // value, and normalizable whitespace is preserved by replacing it 337013481Sgiacomo.travaglini@arm.com // with character references. 337113481Sgiacomo.travaglini@arm.com static std::string EscapeXml(const std::string& str, bool is_attribute); 337213481Sgiacomo.travaglini@arm.com 337313481Sgiacomo.travaglini@arm.com // Returns the given string with all characters invalid in XML removed. 337413481Sgiacomo.travaglini@arm.com static std::string RemoveInvalidXmlCharacters(const std::string& str); 337513481Sgiacomo.travaglini@arm.com 337613481Sgiacomo.travaglini@arm.com // Convenience wrapper around EscapeXml when str is an attribute value. 337713481Sgiacomo.travaglini@arm.com static std::string EscapeXmlAttribute(const std::string& str) { 337813481Sgiacomo.travaglini@arm.com return EscapeXml(str, true); 337913481Sgiacomo.travaglini@arm.com } 338013481Sgiacomo.travaglini@arm.com 338113481Sgiacomo.travaglini@arm.com // Convenience wrapper around EscapeXml when str is not an attribute value. 338213481Sgiacomo.travaglini@arm.com static std::string EscapeXmlText(const char* str) { 338313481Sgiacomo.travaglini@arm.com return EscapeXml(str, false); 338413481Sgiacomo.travaglini@arm.com } 338513481Sgiacomo.travaglini@arm.com 338613481Sgiacomo.travaglini@arm.com // Verifies that the given attribute belongs to the given element and 338713481Sgiacomo.travaglini@arm.com // streams the attribute as XML. 338813481Sgiacomo.travaglini@arm.com static void OutputXmlAttribute(std::ostream* stream, 338913481Sgiacomo.travaglini@arm.com const std::string& element_name, 339013481Sgiacomo.travaglini@arm.com const std::string& name, 339113481Sgiacomo.travaglini@arm.com const std::string& value); 339213481Sgiacomo.travaglini@arm.com 339313481Sgiacomo.travaglini@arm.com // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. 339413481Sgiacomo.travaglini@arm.com static void OutputXmlCDataSection(::std::ostream* stream, const char* data); 339513481Sgiacomo.travaglini@arm.com 339613481Sgiacomo.travaglini@arm.com // Streams an XML representation of a TestInfo object. 339713481Sgiacomo.travaglini@arm.com static void OutputXmlTestInfo(::std::ostream* stream, 339813481Sgiacomo.travaglini@arm.com const char* test_case_name, 339913481Sgiacomo.travaglini@arm.com const TestInfo& test_info); 340013481Sgiacomo.travaglini@arm.com 340113481Sgiacomo.travaglini@arm.com // Prints an XML representation of a TestCase object 340213481Sgiacomo.travaglini@arm.com static void PrintXmlTestCase(::std::ostream* stream, 340313481Sgiacomo.travaglini@arm.com const TestCase& test_case); 340413481Sgiacomo.travaglini@arm.com 340513481Sgiacomo.travaglini@arm.com // Prints an XML summary of unit_test to output stream out. 340613481Sgiacomo.travaglini@arm.com static void PrintXmlUnitTest(::std::ostream* stream, 340713481Sgiacomo.travaglini@arm.com const UnitTest& unit_test); 340813481Sgiacomo.travaglini@arm.com 340913481Sgiacomo.travaglini@arm.com // Produces a string representing the test properties in a result as space 341013481Sgiacomo.travaglini@arm.com // delimited XML attributes based on the property key="value" pairs. 341113481Sgiacomo.travaglini@arm.com // When the std::string is not empty, it includes a space at the beginning, 341213481Sgiacomo.travaglini@arm.com // to delimit this attribute from prior attributes. 341313481Sgiacomo.travaglini@arm.com static std::string TestPropertiesAsXmlAttributes(const TestResult& result); 341413481Sgiacomo.travaglini@arm.com 341513481Sgiacomo.travaglini@arm.com // The output file. 341613481Sgiacomo.travaglini@arm.com const std::string output_file_; 341713481Sgiacomo.travaglini@arm.com 341813481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); 341913481Sgiacomo.travaglini@arm.com}; 342013481Sgiacomo.travaglini@arm.com 342113481Sgiacomo.travaglini@arm.com// Creates a new XmlUnitTestResultPrinter. 342213481Sgiacomo.travaglini@arm.comXmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) 342313481Sgiacomo.travaglini@arm.com : output_file_(output_file) { 342413481Sgiacomo.travaglini@arm.com if (output_file_.c_str() == NULL || output_file_.empty()) { 342513481Sgiacomo.travaglini@arm.com fprintf(stderr, "XML output file may not be null\n"); 342613481Sgiacomo.travaglini@arm.com fflush(stderr); 342713481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 342813481Sgiacomo.travaglini@arm.com } 342913481Sgiacomo.travaglini@arm.com} 343013481Sgiacomo.travaglini@arm.com 343113481Sgiacomo.travaglini@arm.com// Called after the unit test ends. 343213481Sgiacomo.travaglini@arm.comvoid XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 343313481Sgiacomo.travaglini@arm.com int /*iteration*/) { 343413481Sgiacomo.travaglini@arm.com FILE* xmlout = NULL; 343513481Sgiacomo.travaglini@arm.com FilePath output_file(output_file_); 343613481Sgiacomo.travaglini@arm.com FilePath output_dir(output_file.RemoveFileName()); 343713481Sgiacomo.travaglini@arm.com 343813481Sgiacomo.travaglini@arm.com if (output_dir.CreateDirectoriesRecursively()) { 343913481Sgiacomo.travaglini@arm.com xmlout = posix::FOpen(output_file_.c_str(), "w"); 344013481Sgiacomo.travaglini@arm.com } 344113481Sgiacomo.travaglini@arm.com if (xmlout == NULL) { 344213481Sgiacomo.travaglini@arm.com // TODO(wan): report the reason of the failure. 344313481Sgiacomo.travaglini@arm.com // 344413481Sgiacomo.travaglini@arm.com // We don't do it for now as: 344513481Sgiacomo.travaglini@arm.com // 344613481Sgiacomo.travaglini@arm.com // 1. There is no urgent need for it. 344713481Sgiacomo.travaglini@arm.com // 2. It's a bit involved to make the errno variable thread-safe on 344813481Sgiacomo.travaglini@arm.com // all three operating systems (Linux, Windows, and Mac OS). 344913481Sgiacomo.travaglini@arm.com // 3. To interpret the meaning of errno in a thread-safe way, 345013481Sgiacomo.travaglini@arm.com // we need the strerror_r() function, which is not available on 345113481Sgiacomo.travaglini@arm.com // Windows. 345213481Sgiacomo.travaglini@arm.com fprintf(stderr, 345313481Sgiacomo.travaglini@arm.com "Unable to open file \"%s\"\n", 345413481Sgiacomo.travaglini@arm.com output_file_.c_str()); 345513481Sgiacomo.travaglini@arm.com fflush(stderr); 345613481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 345713481Sgiacomo.travaglini@arm.com } 345813481Sgiacomo.travaglini@arm.com std::stringstream stream; 345913481Sgiacomo.travaglini@arm.com PrintXmlUnitTest(&stream, unit_test); 346013481Sgiacomo.travaglini@arm.com fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); 346113481Sgiacomo.travaglini@arm.com fclose(xmlout); 346213481Sgiacomo.travaglini@arm.com} 346313481Sgiacomo.travaglini@arm.com 346413481Sgiacomo.travaglini@arm.com// Returns an XML-escaped copy of the input string str. If is_attribute 346513481Sgiacomo.travaglini@arm.com// is true, the text is meant to appear as an attribute value, and 346613481Sgiacomo.travaglini@arm.com// normalizable whitespace is preserved by replacing it with character 346713481Sgiacomo.travaglini@arm.com// references. 346813481Sgiacomo.travaglini@arm.com// 346913481Sgiacomo.travaglini@arm.com// Invalid XML characters in str, if any, are stripped from the output. 347013481Sgiacomo.travaglini@arm.com// It is expected that most, if not all, of the text processed by this 347113481Sgiacomo.travaglini@arm.com// module will consist of ordinary English text. 347213481Sgiacomo.travaglini@arm.com// If this module is ever modified to produce version 1.1 XML output, 347313481Sgiacomo.travaglini@arm.com// most invalid characters can be retained using character references. 347413481Sgiacomo.travaglini@arm.com// TODO(wan): It might be nice to have a minimally invasive, human-readable 347513481Sgiacomo.travaglini@arm.com// escaping scheme for invalid characters, rather than dropping them. 347613481Sgiacomo.travaglini@arm.comstd::string XmlUnitTestResultPrinter::EscapeXml( 347713481Sgiacomo.travaglini@arm.com const std::string& str, bool is_attribute) { 347813481Sgiacomo.travaglini@arm.com Message m; 347913481Sgiacomo.travaglini@arm.com 348013481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < str.size(); ++i) { 348113481Sgiacomo.travaglini@arm.com const char ch = str[i]; 348213481Sgiacomo.travaglini@arm.com switch (ch) { 348313481Sgiacomo.travaglini@arm.com case '<': 348413481Sgiacomo.travaglini@arm.com m << "<"; 348513481Sgiacomo.travaglini@arm.com break; 348613481Sgiacomo.travaglini@arm.com case '>': 348713481Sgiacomo.travaglini@arm.com m << ">"; 348813481Sgiacomo.travaglini@arm.com break; 348913481Sgiacomo.travaglini@arm.com case '&': 349013481Sgiacomo.travaglini@arm.com m << "&"; 349113481Sgiacomo.travaglini@arm.com break; 349213481Sgiacomo.travaglini@arm.com case '\'': 349313481Sgiacomo.travaglini@arm.com if (is_attribute) 349413481Sgiacomo.travaglini@arm.com m << "'"; 349513481Sgiacomo.travaglini@arm.com else 349613481Sgiacomo.travaglini@arm.com m << '\''; 349713481Sgiacomo.travaglini@arm.com break; 349813481Sgiacomo.travaglini@arm.com case '"': 349913481Sgiacomo.travaglini@arm.com if (is_attribute) 350013481Sgiacomo.travaglini@arm.com m << """; 350113481Sgiacomo.travaglini@arm.com else 350213481Sgiacomo.travaglini@arm.com m << '"'; 350313481Sgiacomo.travaglini@arm.com break; 350413481Sgiacomo.travaglini@arm.com default: 350513481Sgiacomo.travaglini@arm.com if (IsValidXmlCharacter(ch)) { 350613481Sgiacomo.travaglini@arm.com if (is_attribute && IsNormalizableWhitespace(ch)) 350713481Sgiacomo.travaglini@arm.com m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch)) 350813481Sgiacomo.travaglini@arm.com << ";"; 350913481Sgiacomo.travaglini@arm.com else 351013481Sgiacomo.travaglini@arm.com m << ch; 351113481Sgiacomo.travaglini@arm.com } 351213481Sgiacomo.travaglini@arm.com break; 351313481Sgiacomo.travaglini@arm.com } 351413481Sgiacomo.travaglini@arm.com } 351513481Sgiacomo.travaglini@arm.com 351613481Sgiacomo.travaglini@arm.com return m.GetString(); 351713481Sgiacomo.travaglini@arm.com} 351813481Sgiacomo.travaglini@arm.com 351913481Sgiacomo.travaglini@arm.com// Returns the given string with all characters invalid in XML removed. 352013481Sgiacomo.travaglini@arm.com// Currently invalid characters are dropped from the string. An 352113481Sgiacomo.travaglini@arm.com// alternative is to replace them with certain characters such as . or ?. 352213481Sgiacomo.travaglini@arm.comstd::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters( 352313481Sgiacomo.travaglini@arm.com const std::string& str) { 352413481Sgiacomo.travaglini@arm.com std::string output; 352513481Sgiacomo.travaglini@arm.com output.reserve(str.size()); 352613481Sgiacomo.travaglini@arm.com for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) 352713481Sgiacomo.travaglini@arm.com if (IsValidXmlCharacter(*it)) 352813481Sgiacomo.travaglini@arm.com output.push_back(*it); 352913481Sgiacomo.travaglini@arm.com 353013481Sgiacomo.travaglini@arm.com return output; 353113481Sgiacomo.travaglini@arm.com} 353213481Sgiacomo.travaglini@arm.com 353313481Sgiacomo.travaglini@arm.com// The following routines generate an XML representation of a UnitTest 353413481Sgiacomo.travaglini@arm.com// object. 353513481Sgiacomo.travaglini@arm.com// 353613481Sgiacomo.travaglini@arm.com// This is how Google Test concepts map to the DTD: 353713481Sgiacomo.travaglini@arm.com// 353813481Sgiacomo.travaglini@arm.com// <testsuites name="AllTests"> <-- corresponds to a UnitTest object 353913481Sgiacomo.travaglini@arm.com// <testsuite name="testcase-name"> <-- corresponds to a TestCase object 354013481Sgiacomo.travaglini@arm.com// <testcase name="test-name"> <-- corresponds to a TestInfo object 354113481Sgiacomo.travaglini@arm.com// <failure message="...">...</failure> 354213481Sgiacomo.travaglini@arm.com// <failure message="...">...</failure> 354313481Sgiacomo.travaglini@arm.com// <failure message="...">...</failure> 354413481Sgiacomo.travaglini@arm.com// <-- individual assertion failures 354513481Sgiacomo.travaglini@arm.com// </testcase> 354613481Sgiacomo.travaglini@arm.com// </testsuite> 354713481Sgiacomo.travaglini@arm.com// </testsuites> 354813481Sgiacomo.travaglini@arm.com 354913481Sgiacomo.travaglini@arm.com// Formats the given time in milliseconds as seconds. 355013481Sgiacomo.travaglini@arm.comstd::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { 355113481Sgiacomo.travaglini@arm.com ::std::stringstream ss; 355213481Sgiacomo.travaglini@arm.com ss << (static_cast<double>(ms) * 1e-3); 355313481Sgiacomo.travaglini@arm.com return ss.str(); 355413481Sgiacomo.travaglini@arm.com} 355513481Sgiacomo.travaglini@arm.com 355613481Sgiacomo.travaglini@arm.comstatic bool PortableLocaltime(time_t seconds, struct tm* out) { 355713481Sgiacomo.travaglini@arm.com#if defined(_MSC_VER) 355813481Sgiacomo.travaglini@arm.com return localtime_s(out, &seconds) == 0; 355913481Sgiacomo.travaglini@arm.com#elif defined(__MINGW32__) || defined(__MINGW64__) 356013481Sgiacomo.travaglini@arm.com // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses 356113481Sgiacomo.travaglini@arm.com // Windows' localtime(), which has a thread-local tm buffer. 356213481Sgiacomo.travaglini@arm.com struct tm* tm_ptr = localtime(&seconds); // NOLINT 356313481Sgiacomo.travaglini@arm.com if (tm_ptr == NULL) 356413481Sgiacomo.travaglini@arm.com return false; 356513481Sgiacomo.travaglini@arm.com *out = *tm_ptr; 356613481Sgiacomo.travaglini@arm.com return true; 356713481Sgiacomo.travaglini@arm.com#else 356813481Sgiacomo.travaglini@arm.com return localtime_r(&seconds, out) != NULL; 356913481Sgiacomo.travaglini@arm.com#endif 357013481Sgiacomo.travaglini@arm.com} 357113481Sgiacomo.travaglini@arm.com 357213481Sgiacomo.travaglini@arm.com// Converts the given epoch time in milliseconds to a date string in the ISO 357313481Sgiacomo.travaglini@arm.com// 8601 format, without the timezone information. 357413481Sgiacomo.travaglini@arm.comstd::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) { 357513481Sgiacomo.travaglini@arm.com struct tm time_struct; 357613481Sgiacomo.travaglini@arm.com if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct)) 357713481Sgiacomo.travaglini@arm.com return ""; 357813481Sgiacomo.travaglini@arm.com // YYYY-MM-DDThh:mm:ss 357913481Sgiacomo.travaglini@arm.com return StreamableToString(time_struct.tm_year + 1900) + "-" + 358013481Sgiacomo.travaglini@arm.com String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" + 358113481Sgiacomo.travaglini@arm.com String::FormatIntWidth2(time_struct.tm_mday) + "T" + 358213481Sgiacomo.travaglini@arm.com String::FormatIntWidth2(time_struct.tm_hour) + ":" + 358313481Sgiacomo.travaglini@arm.com String::FormatIntWidth2(time_struct.tm_min) + ":" + 358413481Sgiacomo.travaglini@arm.com String::FormatIntWidth2(time_struct.tm_sec); 358513481Sgiacomo.travaglini@arm.com} 358613481Sgiacomo.travaglini@arm.com 358713481Sgiacomo.travaglini@arm.com// Streams an XML CDATA section, escaping invalid CDATA sequences as needed. 358813481Sgiacomo.travaglini@arm.comvoid XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, 358913481Sgiacomo.travaglini@arm.com const char* data) { 359013481Sgiacomo.travaglini@arm.com const char* segment = data; 359113481Sgiacomo.travaglini@arm.com *stream << "<![CDATA["; 359213481Sgiacomo.travaglini@arm.com for (;;) { 359313481Sgiacomo.travaglini@arm.com const char* const next_segment = strstr(segment, "]]>"); 359413481Sgiacomo.travaglini@arm.com if (next_segment != NULL) { 359513481Sgiacomo.travaglini@arm.com stream->write( 359613481Sgiacomo.travaglini@arm.com segment, static_cast<std::streamsize>(next_segment - segment)); 359713481Sgiacomo.travaglini@arm.com *stream << "]]>]]><![CDATA["; 359813481Sgiacomo.travaglini@arm.com segment = next_segment + strlen("]]>"); 359913481Sgiacomo.travaglini@arm.com } else { 360013481Sgiacomo.travaglini@arm.com *stream << segment; 360113481Sgiacomo.travaglini@arm.com break; 360213481Sgiacomo.travaglini@arm.com } 360313481Sgiacomo.travaglini@arm.com } 360413481Sgiacomo.travaglini@arm.com *stream << "]]>"; 360513481Sgiacomo.travaglini@arm.com} 360613481Sgiacomo.travaglini@arm.com 360713481Sgiacomo.travaglini@arm.comvoid XmlUnitTestResultPrinter::OutputXmlAttribute( 360813481Sgiacomo.travaglini@arm.com std::ostream* stream, 360913481Sgiacomo.travaglini@arm.com const std::string& element_name, 361013481Sgiacomo.travaglini@arm.com const std::string& name, 361113481Sgiacomo.travaglini@arm.com const std::string& value) { 361213481Sgiacomo.travaglini@arm.com const std::vector<std::string>& allowed_names = 361313481Sgiacomo.travaglini@arm.com GetReservedAttributesForElement(element_name); 361413481Sgiacomo.travaglini@arm.com 361513481Sgiacomo.travaglini@arm.com GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != 361613481Sgiacomo.travaglini@arm.com allowed_names.end()) 361713481Sgiacomo.travaglini@arm.com << "Attribute " << name << " is not allowed for element <" << element_name 361813481Sgiacomo.travaglini@arm.com << ">."; 361913481Sgiacomo.travaglini@arm.com 362013481Sgiacomo.travaglini@arm.com *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\""; 362113481Sgiacomo.travaglini@arm.com} 362213481Sgiacomo.travaglini@arm.com 362313481Sgiacomo.travaglini@arm.com// Prints an XML representation of a TestInfo object. 362413481Sgiacomo.travaglini@arm.com// TODO(wan): There is also value in printing properties with the plain printer. 362513481Sgiacomo.travaglini@arm.comvoid XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, 362613481Sgiacomo.travaglini@arm.com const char* test_case_name, 362713481Sgiacomo.travaglini@arm.com const TestInfo& test_info) { 362813481Sgiacomo.travaglini@arm.com const TestResult& result = *test_info.result(); 362913481Sgiacomo.travaglini@arm.com const std::string kTestcase = "testcase"; 363013481Sgiacomo.travaglini@arm.com 363113481Sgiacomo.travaglini@arm.com *stream << " <testcase"; 363213481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestcase, "name", test_info.name()); 363313481Sgiacomo.travaglini@arm.com 363413481Sgiacomo.travaglini@arm.com if (test_info.value_param() != NULL) { 363513481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestcase, "value_param", 363613481Sgiacomo.travaglini@arm.com test_info.value_param()); 363713481Sgiacomo.travaglini@arm.com } 363813481Sgiacomo.travaglini@arm.com if (test_info.type_param() != NULL) { 363913481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param()); 364013481Sgiacomo.travaglini@arm.com } 364113481Sgiacomo.travaglini@arm.com 364213481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestcase, "status", 364313481Sgiacomo.travaglini@arm.com test_info.should_run() ? "run" : "notrun"); 364413481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestcase, "time", 364513481Sgiacomo.travaglini@arm.com FormatTimeInMillisAsSeconds(result.elapsed_time())); 364613481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestcase, "classname", test_case_name); 364713481Sgiacomo.travaglini@arm.com *stream << TestPropertiesAsXmlAttributes(result); 364813481Sgiacomo.travaglini@arm.com 364913481Sgiacomo.travaglini@arm.com int failures = 0; 365013481Sgiacomo.travaglini@arm.com for (int i = 0; i < result.total_part_count(); ++i) { 365113481Sgiacomo.travaglini@arm.com const TestPartResult& part = result.GetTestPartResult(i); 365213481Sgiacomo.travaglini@arm.com if (part.failed()) { 365313481Sgiacomo.travaglini@arm.com if (++failures == 1) { 365413481Sgiacomo.travaglini@arm.com *stream << ">\n"; 365513481Sgiacomo.travaglini@arm.com } 365613481Sgiacomo.travaglini@arm.com const string location = internal::FormatCompilerIndependentFileLocation( 365713481Sgiacomo.travaglini@arm.com part.file_name(), part.line_number()); 365813481Sgiacomo.travaglini@arm.com const string summary = location + "\n" + part.summary(); 365913481Sgiacomo.travaglini@arm.com *stream << " <failure message=\"" 366013481Sgiacomo.travaglini@arm.com << EscapeXmlAttribute(summary.c_str()) 366113481Sgiacomo.travaglini@arm.com << "\" type=\"\">"; 366213481Sgiacomo.travaglini@arm.com const string detail = location + "\n" + part.message(); 366313481Sgiacomo.travaglini@arm.com OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); 366413481Sgiacomo.travaglini@arm.com *stream << "</failure>\n"; 366513481Sgiacomo.travaglini@arm.com } 366613481Sgiacomo.travaglini@arm.com } 366713481Sgiacomo.travaglini@arm.com 366813481Sgiacomo.travaglini@arm.com if (failures == 0) 366913481Sgiacomo.travaglini@arm.com *stream << " />\n"; 367013481Sgiacomo.travaglini@arm.com else 367113481Sgiacomo.travaglini@arm.com *stream << " </testcase>\n"; 367213481Sgiacomo.travaglini@arm.com} 367313481Sgiacomo.travaglini@arm.com 367413481Sgiacomo.travaglini@arm.com// Prints an XML representation of a TestCase object 367513481Sgiacomo.travaglini@arm.comvoid XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream, 367613481Sgiacomo.travaglini@arm.com const TestCase& test_case) { 367713481Sgiacomo.travaglini@arm.com const std::string kTestsuite = "testsuite"; 367813481Sgiacomo.travaglini@arm.com *stream << " <" << kTestsuite; 367913481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuite, "name", test_case.name()); 368013481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuite, "tests", 368113481Sgiacomo.travaglini@arm.com StreamableToString(test_case.reportable_test_count())); 368213481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuite, "failures", 368313481Sgiacomo.travaglini@arm.com StreamableToString(test_case.failed_test_count())); 368413481Sgiacomo.travaglini@arm.com OutputXmlAttribute( 368513481Sgiacomo.travaglini@arm.com stream, kTestsuite, "disabled", 368613481Sgiacomo.travaglini@arm.com StreamableToString(test_case.reportable_disabled_test_count())); 368713481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuite, "errors", "0"); 368813481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuite, "time", 368913481Sgiacomo.travaglini@arm.com FormatTimeInMillisAsSeconds(test_case.elapsed_time())); 369013481Sgiacomo.travaglini@arm.com *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result()) 369113481Sgiacomo.travaglini@arm.com << ">\n"; 369213481Sgiacomo.travaglini@arm.com 369313481Sgiacomo.travaglini@arm.com for (int i = 0; i < test_case.total_test_count(); ++i) { 369413481Sgiacomo.travaglini@arm.com if (test_case.GetTestInfo(i)->is_reportable()) 369513481Sgiacomo.travaglini@arm.com OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i)); 369613481Sgiacomo.travaglini@arm.com } 369713481Sgiacomo.travaglini@arm.com *stream << " </" << kTestsuite << ">\n"; 369813481Sgiacomo.travaglini@arm.com} 369913481Sgiacomo.travaglini@arm.com 370013481Sgiacomo.travaglini@arm.com// Prints an XML summary of unit_test to output stream out. 370113481Sgiacomo.travaglini@arm.comvoid XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream, 370213481Sgiacomo.travaglini@arm.com const UnitTest& unit_test) { 370313481Sgiacomo.travaglini@arm.com const std::string kTestsuites = "testsuites"; 370413481Sgiacomo.travaglini@arm.com 370513481Sgiacomo.travaglini@arm.com *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; 370613481Sgiacomo.travaglini@arm.com *stream << "<" << kTestsuites; 370713481Sgiacomo.travaglini@arm.com 370813481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuites, "tests", 370913481Sgiacomo.travaglini@arm.com StreamableToString(unit_test.reportable_test_count())); 371013481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuites, "failures", 371113481Sgiacomo.travaglini@arm.com StreamableToString(unit_test.failed_test_count())); 371213481Sgiacomo.travaglini@arm.com OutputXmlAttribute( 371313481Sgiacomo.travaglini@arm.com stream, kTestsuites, "disabled", 371413481Sgiacomo.travaglini@arm.com StreamableToString(unit_test.reportable_disabled_test_count())); 371513481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuites, "errors", "0"); 371613481Sgiacomo.travaglini@arm.com OutputXmlAttribute( 371713481Sgiacomo.travaglini@arm.com stream, kTestsuites, "timestamp", 371813481Sgiacomo.travaglini@arm.com FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp())); 371913481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuites, "time", 372013481Sgiacomo.travaglini@arm.com FormatTimeInMillisAsSeconds(unit_test.elapsed_time())); 372113481Sgiacomo.travaglini@arm.com 372213481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(shuffle)) { 372313481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuites, "random_seed", 372413481Sgiacomo.travaglini@arm.com StreamableToString(unit_test.random_seed())); 372513481Sgiacomo.travaglini@arm.com } 372613481Sgiacomo.travaglini@arm.com 372713481Sgiacomo.travaglini@arm.com *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result()); 372813481Sgiacomo.travaglini@arm.com 372913481Sgiacomo.travaglini@arm.com OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); 373013481Sgiacomo.travaglini@arm.com *stream << ">\n"; 373113481Sgiacomo.travaglini@arm.com 373213481Sgiacomo.travaglini@arm.com for (int i = 0; i < unit_test.total_test_case_count(); ++i) { 373313481Sgiacomo.travaglini@arm.com if (unit_test.GetTestCase(i)->reportable_test_count() > 0) 373413481Sgiacomo.travaglini@arm.com PrintXmlTestCase(stream, *unit_test.GetTestCase(i)); 373513481Sgiacomo.travaglini@arm.com } 373613481Sgiacomo.travaglini@arm.com *stream << "</" << kTestsuites << ">\n"; 373713481Sgiacomo.travaglini@arm.com} 373813481Sgiacomo.travaglini@arm.com 373913481Sgiacomo.travaglini@arm.com// Produces a string representing the test properties in a result as space 374013481Sgiacomo.travaglini@arm.com// delimited XML attributes based on the property key="value" pairs. 374113481Sgiacomo.travaglini@arm.comstd::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( 374213481Sgiacomo.travaglini@arm.com const TestResult& result) { 374313481Sgiacomo.travaglini@arm.com Message attributes; 374413481Sgiacomo.travaglini@arm.com for (int i = 0; i < result.test_property_count(); ++i) { 374513481Sgiacomo.travaglini@arm.com const TestProperty& property = result.GetTestProperty(i); 374613481Sgiacomo.travaglini@arm.com attributes << " " << property.key() << "=" 374713481Sgiacomo.travaglini@arm.com << "\"" << EscapeXmlAttribute(property.value()) << "\""; 374813481Sgiacomo.travaglini@arm.com } 374913481Sgiacomo.travaglini@arm.com return attributes.GetString(); 375013481Sgiacomo.travaglini@arm.com} 375113481Sgiacomo.travaglini@arm.com 375213481Sgiacomo.travaglini@arm.com// End XmlUnitTestResultPrinter 375313481Sgiacomo.travaglini@arm.com 375413481Sgiacomo.travaglini@arm.com#if GTEST_CAN_STREAM_RESULTS_ 375513481Sgiacomo.travaglini@arm.com 375613481Sgiacomo.travaglini@arm.com// Checks if str contains '=', '&', '%' or '\n' characters. If yes, 375713481Sgiacomo.travaglini@arm.com// replaces them by "%xx" where xx is their hexadecimal value. For 375813481Sgiacomo.travaglini@arm.com// example, replaces "=" with "%3D". This algorithm is O(strlen(str)) 375913481Sgiacomo.travaglini@arm.com// in both time and space -- important as the input str may contain an 376013481Sgiacomo.travaglini@arm.com// arbitrarily long test failure message and stack trace. 376113481Sgiacomo.travaglini@arm.comstring StreamingListener::UrlEncode(const char* str) { 376213481Sgiacomo.travaglini@arm.com string result; 376313481Sgiacomo.travaglini@arm.com result.reserve(strlen(str) + 1); 376413481Sgiacomo.travaglini@arm.com for (char ch = *str; ch != '\0'; ch = *++str) { 376513481Sgiacomo.travaglini@arm.com switch (ch) { 376613481Sgiacomo.travaglini@arm.com case '%': 376713481Sgiacomo.travaglini@arm.com case '=': 376813481Sgiacomo.travaglini@arm.com case '&': 376913481Sgiacomo.travaglini@arm.com case '\n': 377013481Sgiacomo.travaglini@arm.com result.append("%" + String::FormatByte(static_cast<unsigned char>(ch))); 377113481Sgiacomo.travaglini@arm.com break; 377213481Sgiacomo.travaglini@arm.com default: 377313481Sgiacomo.travaglini@arm.com result.push_back(ch); 377413481Sgiacomo.travaglini@arm.com break; 377513481Sgiacomo.travaglini@arm.com } 377613481Sgiacomo.travaglini@arm.com } 377713481Sgiacomo.travaglini@arm.com return result; 377813481Sgiacomo.travaglini@arm.com} 377913481Sgiacomo.travaglini@arm.com 378013481Sgiacomo.travaglini@arm.comvoid StreamingListener::SocketWriter::MakeConnection() { 378113481Sgiacomo.travaglini@arm.com GTEST_CHECK_(sockfd_ == -1) 378213481Sgiacomo.travaglini@arm.com << "MakeConnection() can't be called when there is already a connection."; 378313481Sgiacomo.travaglini@arm.com 378413481Sgiacomo.travaglini@arm.com addrinfo hints; 378513481Sgiacomo.travaglini@arm.com memset(&hints, 0, sizeof(hints)); 378613481Sgiacomo.travaglini@arm.com hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. 378713481Sgiacomo.travaglini@arm.com hints.ai_socktype = SOCK_STREAM; 378813481Sgiacomo.travaglini@arm.com addrinfo* servinfo = NULL; 378913481Sgiacomo.travaglini@arm.com 379013481Sgiacomo.travaglini@arm.com // Use the getaddrinfo() to get a linked list of IP addresses for 379113481Sgiacomo.travaglini@arm.com // the given host name. 379213481Sgiacomo.travaglini@arm.com const int error_num = getaddrinfo( 379313481Sgiacomo.travaglini@arm.com host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); 379413481Sgiacomo.travaglini@arm.com if (error_num != 0) { 379513481Sgiacomo.travaglini@arm.com GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " 379613481Sgiacomo.travaglini@arm.com << gai_strerror(error_num); 379713481Sgiacomo.travaglini@arm.com } 379813481Sgiacomo.travaglini@arm.com 379913481Sgiacomo.travaglini@arm.com // Loop through all the results and connect to the first we can. 380013481Sgiacomo.travaglini@arm.com for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; 380113481Sgiacomo.travaglini@arm.com cur_addr = cur_addr->ai_next) { 380213481Sgiacomo.travaglini@arm.com sockfd_ = socket( 380313481Sgiacomo.travaglini@arm.com cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); 380413481Sgiacomo.travaglini@arm.com if (sockfd_ != -1) { 380513481Sgiacomo.travaglini@arm.com // Connect the client socket to the server socket. 380613481Sgiacomo.travaglini@arm.com if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { 380713481Sgiacomo.travaglini@arm.com close(sockfd_); 380813481Sgiacomo.travaglini@arm.com sockfd_ = -1; 380913481Sgiacomo.travaglini@arm.com } 381013481Sgiacomo.travaglini@arm.com } 381113481Sgiacomo.travaglini@arm.com } 381213481Sgiacomo.travaglini@arm.com 381313481Sgiacomo.travaglini@arm.com freeaddrinfo(servinfo); // all done with this structure 381413481Sgiacomo.travaglini@arm.com 381513481Sgiacomo.travaglini@arm.com if (sockfd_ == -1) { 381613481Sgiacomo.travaglini@arm.com GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " 381713481Sgiacomo.travaglini@arm.com << host_name_ << ":" << port_num_; 381813481Sgiacomo.travaglini@arm.com } 381913481Sgiacomo.travaglini@arm.com} 382013481Sgiacomo.travaglini@arm.com 382113481Sgiacomo.travaglini@arm.com// End of class Streaming Listener 382213481Sgiacomo.travaglini@arm.com#endif // GTEST_CAN_STREAM_RESULTS__ 382313481Sgiacomo.travaglini@arm.com 382413481Sgiacomo.travaglini@arm.com// Class ScopedTrace 382513481Sgiacomo.travaglini@arm.com 382613481Sgiacomo.travaglini@arm.com// Pushes the given source file location and message onto a per-thread 382713481Sgiacomo.travaglini@arm.com// trace stack maintained by Google Test. 382813481Sgiacomo.travaglini@arm.comScopedTrace::ScopedTrace(const char* file, int line, const Message& message) 382913481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { 383013481Sgiacomo.travaglini@arm.com TraceInfo trace; 383113481Sgiacomo.travaglini@arm.com trace.file = file; 383213481Sgiacomo.travaglini@arm.com trace.line = line; 383313481Sgiacomo.travaglini@arm.com trace.message = message.GetString(); 383413481Sgiacomo.travaglini@arm.com 383513481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()->PushGTestTrace(trace); 383613481Sgiacomo.travaglini@arm.com} 383713481Sgiacomo.travaglini@arm.com 383813481Sgiacomo.travaglini@arm.com// Pops the info pushed by the c'tor. 383913481Sgiacomo.travaglini@arm.comScopedTrace::~ScopedTrace() 384013481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { 384113481Sgiacomo.travaglini@arm.com UnitTest::GetInstance()->PopGTestTrace(); 384213481Sgiacomo.travaglini@arm.com} 384313481Sgiacomo.travaglini@arm.com 384413481Sgiacomo.travaglini@arm.com 384513481Sgiacomo.travaglini@arm.com// class OsStackTraceGetter 384613481Sgiacomo.travaglini@arm.com 384713481Sgiacomo.travaglini@arm.comconst char* const OsStackTraceGetterInterface::kElidedFramesMarker = 384813481Sgiacomo.travaglini@arm.com "... " GTEST_NAME_ " internal frames ..."; 384913481Sgiacomo.travaglini@arm.com 385013481Sgiacomo.travaglini@arm.comstring OsStackTraceGetter::CurrentStackTrace(int /*max_depth*/, 385113481Sgiacomo.travaglini@arm.com int /*skip_count*/) { 385213481Sgiacomo.travaglini@arm.com return ""; 385313481Sgiacomo.travaglini@arm.com} 385413481Sgiacomo.travaglini@arm.com 385513481Sgiacomo.travaglini@arm.comvoid OsStackTraceGetter::UponLeavingGTest() {} 385613481Sgiacomo.travaglini@arm.com 385713481Sgiacomo.travaglini@arm.com// A helper class that creates the premature-exit file in its 385813481Sgiacomo.travaglini@arm.com// constructor and deletes the file in its destructor. 385913481Sgiacomo.travaglini@arm.comclass ScopedPrematureExitFile { 386013481Sgiacomo.travaglini@arm.com public: 386113481Sgiacomo.travaglini@arm.com explicit ScopedPrematureExitFile(const char* premature_exit_filepath) 386213481Sgiacomo.travaglini@arm.com : premature_exit_filepath_(premature_exit_filepath) { 386313481Sgiacomo.travaglini@arm.com // If a path to the premature-exit file is specified... 386413481Sgiacomo.travaglini@arm.com if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') { 386513481Sgiacomo.travaglini@arm.com // create the file with a single "0" character in it. I/O 386613481Sgiacomo.travaglini@arm.com // errors are ignored as there's nothing better we can do and we 386713481Sgiacomo.travaglini@arm.com // don't want to fail the test because of this. 386813481Sgiacomo.travaglini@arm.com FILE* pfile = posix::FOpen(premature_exit_filepath, "w"); 386913481Sgiacomo.travaglini@arm.com fwrite("0", 1, 1, pfile); 387013481Sgiacomo.travaglini@arm.com fclose(pfile); 387113481Sgiacomo.travaglini@arm.com } 387213481Sgiacomo.travaglini@arm.com } 387313481Sgiacomo.travaglini@arm.com 387413481Sgiacomo.travaglini@arm.com ~ScopedPrematureExitFile() { 387513481Sgiacomo.travaglini@arm.com if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') { 387613481Sgiacomo.travaglini@arm.com remove(premature_exit_filepath_); 387713481Sgiacomo.travaglini@arm.com } 387813481Sgiacomo.travaglini@arm.com } 387913481Sgiacomo.travaglini@arm.com 388013481Sgiacomo.travaglini@arm.com private: 388113481Sgiacomo.travaglini@arm.com const char* const premature_exit_filepath_; 388213481Sgiacomo.travaglini@arm.com 388313481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile); 388413481Sgiacomo.travaglini@arm.com}; 388513481Sgiacomo.travaglini@arm.com 388613481Sgiacomo.travaglini@arm.com} // namespace internal 388713481Sgiacomo.travaglini@arm.com 388813481Sgiacomo.travaglini@arm.com// class TestEventListeners 388913481Sgiacomo.travaglini@arm.com 389013481Sgiacomo.travaglini@arm.comTestEventListeners::TestEventListeners() 389113481Sgiacomo.travaglini@arm.com : repeater_(new internal::TestEventRepeater()), 389213481Sgiacomo.travaglini@arm.com default_result_printer_(NULL), 389313481Sgiacomo.travaglini@arm.com default_xml_generator_(NULL) { 389413481Sgiacomo.travaglini@arm.com} 389513481Sgiacomo.travaglini@arm.com 389613481Sgiacomo.travaglini@arm.comTestEventListeners::~TestEventListeners() { delete repeater_; } 389713481Sgiacomo.travaglini@arm.com 389813481Sgiacomo.travaglini@arm.com// Returns the standard listener responsible for the default console 389913481Sgiacomo.travaglini@arm.com// output. Can be removed from the listeners list to shut down default 390013481Sgiacomo.travaglini@arm.com// console output. Note that removing this object from the listener list 390113481Sgiacomo.travaglini@arm.com// with Release transfers its ownership to the user. 390213481Sgiacomo.travaglini@arm.comvoid TestEventListeners::Append(TestEventListener* listener) { 390313481Sgiacomo.travaglini@arm.com repeater_->Append(listener); 390413481Sgiacomo.travaglini@arm.com} 390513481Sgiacomo.travaglini@arm.com 390613481Sgiacomo.travaglini@arm.com// Removes the given event listener from the list and returns it. It then 390713481Sgiacomo.travaglini@arm.com// becomes the caller's responsibility to delete the listener. Returns 390813481Sgiacomo.travaglini@arm.com// NULL if the listener is not found in the list. 390913481Sgiacomo.travaglini@arm.comTestEventListener* TestEventListeners::Release(TestEventListener* listener) { 391013481Sgiacomo.travaglini@arm.com if (listener == default_result_printer_) 391113481Sgiacomo.travaglini@arm.com default_result_printer_ = NULL; 391213481Sgiacomo.travaglini@arm.com else if (listener == default_xml_generator_) 391313481Sgiacomo.travaglini@arm.com default_xml_generator_ = NULL; 391413481Sgiacomo.travaglini@arm.com return repeater_->Release(listener); 391513481Sgiacomo.travaglini@arm.com} 391613481Sgiacomo.travaglini@arm.com 391713481Sgiacomo.travaglini@arm.com// Returns repeater that broadcasts the TestEventListener events to all 391813481Sgiacomo.travaglini@arm.com// subscribers. 391913481Sgiacomo.travaglini@arm.comTestEventListener* TestEventListeners::repeater() { return repeater_; } 392013481Sgiacomo.travaglini@arm.com 392113481Sgiacomo.travaglini@arm.com// Sets the default_result_printer attribute to the provided listener. 392213481Sgiacomo.travaglini@arm.com// The listener is also added to the listener list and previous 392313481Sgiacomo.travaglini@arm.com// default_result_printer is removed from it and deleted. The listener can 392413481Sgiacomo.travaglini@arm.com// also be NULL in which case it will not be added to the list. Does 392513481Sgiacomo.travaglini@arm.com// nothing if the previous and the current listener objects are the same. 392613481Sgiacomo.travaglini@arm.comvoid TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { 392713481Sgiacomo.travaglini@arm.com if (default_result_printer_ != listener) { 392813481Sgiacomo.travaglini@arm.com // It is an error to pass this method a listener that is already in the 392913481Sgiacomo.travaglini@arm.com // list. 393013481Sgiacomo.travaglini@arm.com delete Release(default_result_printer_); 393113481Sgiacomo.travaglini@arm.com default_result_printer_ = listener; 393213481Sgiacomo.travaglini@arm.com if (listener != NULL) 393313481Sgiacomo.travaglini@arm.com Append(listener); 393413481Sgiacomo.travaglini@arm.com } 393513481Sgiacomo.travaglini@arm.com} 393613481Sgiacomo.travaglini@arm.com 393713481Sgiacomo.travaglini@arm.com// Sets the default_xml_generator attribute to the provided listener. The 393813481Sgiacomo.travaglini@arm.com// listener is also added to the listener list and previous 393913481Sgiacomo.travaglini@arm.com// default_xml_generator is removed from it and deleted. The listener can 394013481Sgiacomo.travaglini@arm.com// also be NULL in which case it will not be added to the list. Does 394113481Sgiacomo.travaglini@arm.com// nothing if the previous and the current listener objects are the same. 394213481Sgiacomo.travaglini@arm.comvoid TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { 394313481Sgiacomo.travaglini@arm.com if (default_xml_generator_ != listener) { 394413481Sgiacomo.travaglini@arm.com // It is an error to pass this method a listener that is already in the 394513481Sgiacomo.travaglini@arm.com // list. 394613481Sgiacomo.travaglini@arm.com delete Release(default_xml_generator_); 394713481Sgiacomo.travaglini@arm.com default_xml_generator_ = listener; 394813481Sgiacomo.travaglini@arm.com if (listener != NULL) 394913481Sgiacomo.travaglini@arm.com Append(listener); 395013481Sgiacomo.travaglini@arm.com } 395113481Sgiacomo.travaglini@arm.com} 395213481Sgiacomo.travaglini@arm.com 395313481Sgiacomo.travaglini@arm.com// Controls whether events will be forwarded by the repeater to the 395413481Sgiacomo.travaglini@arm.com// listeners in the list. 395513481Sgiacomo.travaglini@arm.combool TestEventListeners::EventForwardingEnabled() const { 395613481Sgiacomo.travaglini@arm.com return repeater_->forwarding_enabled(); 395713481Sgiacomo.travaglini@arm.com} 395813481Sgiacomo.travaglini@arm.com 395913481Sgiacomo.travaglini@arm.comvoid TestEventListeners::SuppressEventForwarding() { 396013481Sgiacomo.travaglini@arm.com repeater_->set_forwarding_enabled(false); 396113481Sgiacomo.travaglini@arm.com} 396213481Sgiacomo.travaglini@arm.com 396313481Sgiacomo.travaglini@arm.com// class UnitTest 396413481Sgiacomo.travaglini@arm.com 396513481Sgiacomo.travaglini@arm.com// Gets the singleton UnitTest object. The first time this method is 396613481Sgiacomo.travaglini@arm.com// called, a UnitTest object is constructed and returned. Consecutive 396713481Sgiacomo.travaglini@arm.com// calls will return the same object. 396813481Sgiacomo.travaglini@arm.com// 396913481Sgiacomo.travaglini@arm.com// We don't protect this under mutex_ as a user is not supposed to 397013481Sgiacomo.travaglini@arm.com// call this before main() starts, from which point on the return 397113481Sgiacomo.travaglini@arm.com// value will never change. 397213481Sgiacomo.travaglini@arm.comUnitTest* UnitTest::GetInstance() { 397313481Sgiacomo.travaglini@arm.com // When compiled with MSVC 7.1 in optimized mode, destroying the 397413481Sgiacomo.travaglini@arm.com // UnitTest object upon exiting the program messes up the exit code, 397513481Sgiacomo.travaglini@arm.com // causing successful tests to appear failed. We have to use a 397613481Sgiacomo.travaglini@arm.com // different implementation in this case to bypass the compiler bug. 397713481Sgiacomo.travaglini@arm.com // This implementation makes the compiler happy, at the cost of 397813481Sgiacomo.travaglini@arm.com // leaking the UnitTest object. 397913481Sgiacomo.travaglini@arm.com 398013481Sgiacomo.travaglini@arm.com // CodeGear C++Builder insists on a public destructor for the 398113481Sgiacomo.travaglini@arm.com // default implementation. Use this implementation to keep good OO 398213481Sgiacomo.travaglini@arm.com // design with private destructor. 398313481Sgiacomo.travaglini@arm.com 398413481Sgiacomo.travaglini@arm.com#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) 398513481Sgiacomo.travaglini@arm.com static UnitTest* const instance = new UnitTest; 398613481Sgiacomo.travaglini@arm.com return instance; 398713481Sgiacomo.travaglini@arm.com#else 398813481Sgiacomo.travaglini@arm.com static UnitTest instance; 398913481Sgiacomo.travaglini@arm.com return &instance; 399013481Sgiacomo.travaglini@arm.com#endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) 399113481Sgiacomo.travaglini@arm.com} 399213481Sgiacomo.travaglini@arm.com 399313481Sgiacomo.travaglini@arm.com// Gets the number of successful test cases. 399413481Sgiacomo.travaglini@arm.comint UnitTest::successful_test_case_count() const { 399513481Sgiacomo.travaglini@arm.com return impl()->successful_test_case_count(); 399613481Sgiacomo.travaglini@arm.com} 399713481Sgiacomo.travaglini@arm.com 399813481Sgiacomo.travaglini@arm.com// Gets the number of failed test cases. 399913481Sgiacomo.travaglini@arm.comint UnitTest::failed_test_case_count() const { 400013481Sgiacomo.travaglini@arm.com return impl()->failed_test_case_count(); 400113481Sgiacomo.travaglini@arm.com} 400213481Sgiacomo.travaglini@arm.com 400313481Sgiacomo.travaglini@arm.com// Gets the number of all test cases. 400413481Sgiacomo.travaglini@arm.comint UnitTest::total_test_case_count() const { 400513481Sgiacomo.travaglini@arm.com return impl()->total_test_case_count(); 400613481Sgiacomo.travaglini@arm.com} 400713481Sgiacomo.travaglini@arm.com 400813481Sgiacomo.travaglini@arm.com// Gets the number of all test cases that contain at least one test 400913481Sgiacomo.travaglini@arm.com// that should run. 401013481Sgiacomo.travaglini@arm.comint UnitTest::test_case_to_run_count() const { 401113481Sgiacomo.travaglini@arm.com return impl()->test_case_to_run_count(); 401213481Sgiacomo.travaglini@arm.com} 401313481Sgiacomo.travaglini@arm.com 401413481Sgiacomo.travaglini@arm.com// Gets the number of successful tests. 401513481Sgiacomo.travaglini@arm.comint UnitTest::successful_test_count() const { 401613481Sgiacomo.travaglini@arm.com return impl()->successful_test_count(); 401713481Sgiacomo.travaglini@arm.com} 401813481Sgiacomo.travaglini@arm.com 401913481Sgiacomo.travaglini@arm.com// Gets the number of failed tests. 402013481Sgiacomo.travaglini@arm.comint UnitTest::failed_test_count() const { return impl()->failed_test_count(); } 402113481Sgiacomo.travaglini@arm.com 402213481Sgiacomo.travaglini@arm.com// Gets the number of disabled tests that will be reported in the XML report. 402313481Sgiacomo.travaglini@arm.comint UnitTest::reportable_disabled_test_count() const { 402413481Sgiacomo.travaglini@arm.com return impl()->reportable_disabled_test_count(); 402513481Sgiacomo.travaglini@arm.com} 402613481Sgiacomo.travaglini@arm.com 402713481Sgiacomo.travaglini@arm.com// Gets the number of disabled tests. 402813481Sgiacomo.travaglini@arm.comint UnitTest::disabled_test_count() const { 402913481Sgiacomo.travaglini@arm.com return impl()->disabled_test_count(); 403013481Sgiacomo.travaglini@arm.com} 403113481Sgiacomo.travaglini@arm.com 403213481Sgiacomo.travaglini@arm.com// Gets the number of tests to be printed in the XML report. 403313481Sgiacomo.travaglini@arm.comint UnitTest::reportable_test_count() const { 403413481Sgiacomo.travaglini@arm.com return impl()->reportable_test_count(); 403513481Sgiacomo.travaglini@arm.com} 403613481Sgiacomo.travaglini@arm.com 403713481Sgiacomo.travaglini@arm.com// Gets the number of all tests. 403813481Sgiacomo.travaglini@arm.comint UnitTest::total_test_count() const { return impl()->total_test_count(); } 403913481Sgiacomo.travaglini@arm.com 404013481Sgiacomo.travaglini@arm.com// Gets the number of tests that should run. 404113481Sgiacomo.travaglini@arm.comint UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } 404213481Sgiacomo.travaglini@arm.com 404313481Sgiacomo.travaglini@arm.com// Gets the time of the test program start, in ms from the start of the 404413481Sgiacomo.travaglini@arm.com// UNIX epoch. 404513481Sgiacomo.travaglini@arm.cominternal::TimeInMillis UnitTest::start_timestamp() const { 404613481Sgiacomo.travaglini@arm.com return impl()->start_timestamp(); 404713481Sgiacomo.travaglini@arm.com} 404813481Sgiacomo.travaglini@arm.com 404913481Sgiacomo.travaglini@arm.com// Gets the elapsed time, in milliseconds. 405013481Sgiacomo.travaglini@arm.cominternal::TimeInMillis UnitTest::elapsed_time() const { 405113481Sgiacomo.travaglini@arm.com return impl()->elapsed_time(); 405213481Sgiacomo.travaglini@arm.com} 405313481Sgiacomo.travaglini@arm.com 405413481Sgiacomo.travaglini@arm.com// Returns true iff the unit test passed (i.e. all test cases passed). 405513481Sgiacomo.travaglini@arm.combool UnitTest::Passed() const { return impl()->Passed(); } 405613481Sgiacomo.travaglini@arm.com 405713481Sgiacomo.travaglini@arm.com// Returns true iff the unit test failed (i.e. some test case failed 405813481Sgiacomo.travaglini@arm.com// or something outside of all tests failed). 405913481Sgiacomo.travaglini@arm.combool UnitTest::Failed() const { return impl()->Failed(); } 406013481Sgiacomo.travaglini@arm.com 406113481Sgiacomo.travaglini@arm.com// Gets the i-th test case among all the test cases. i can range from 0 to 406213481Sgiacomo.travaglini@arm.com// total_test_case_count() - 1. If i is not in that range, returns NULL. 406313481Sgiacomo.travaglini@arm.comconst TestCase* UnitTest::GetTestCase(int i) const { 406413481Sgiacomo.travaglini@arm.com return impl()->GetTestCase(i); 406513481Sgiacomo.travaglini@arm.com} 406613481Sgiacomo.travaglini@arm.com 406713481Sgiacomo.travaglini@arm.com// Returns the TestResult containing information on test failures and 406813481Sgiacomo.travaglini@arm.com// properties logged outside of individual test cases. 406913481Sgiacomo.travaglini@arm.comconst TestResult& UnitTest::ad_hoc_test_result() const { 407013481Sgiacomo.travaglini@arm.com return *impl()->ad_hoc_test_result(); 407113481Sgiacomo.travaglini@arm.com} 407213481Sgiacomo.travaglini@arm.com 407313481Sgiacomo.travaglini@arm.com// Gets the i-th test case among all the test cases. i can range from 0 to 407413481Sgiacomo.travaglini@arm.com// total_test_case_count() - 1. If i is not in that range, returns NULL. 407513481Sgiacomo.travaglini@arm.comTestCase* UnitTest::GetMutableTestCase(int i) { 407613481Sgiacomo.travaglini@arm.com return impl()->GetMutableTestCase(i); 407713481Sgiacomo.travaglini@arm.com} 407813481Sgiacomo.travaglini@arm.com 407913481Sgiacomo.travaglini@arm.com// Returns the list of event listeners that can be used to track events 408013481Sgiacomo.travaglini@arm.com// inside Google Test. 408113481Sgiacomo.travaglini@arm.comTestEventListeners& UnitTest::listeners() { 408213481Sgiacomo.travaglini@arm.com return *impl()->listeners(); 408313481Sgiacomo.travaglini@arm.com} 408413481Sgiacomo.travaglini@arm.com 408513481Sgiacomo.travaglini@arm.com// Registers and returns a global test environment. When a test 408613481Sgiacomo.travaglini@arm.com// program is run, all global test environments will be set-up in the 408713481Sgiacomo.travaglini@arm.com// order they were registered. After all tests in the program have 408813481Sgiacomo.travaglini@arm.com// finished, all global test environments will be torn-down in the 408913481Sgiacomo.travaglini@arm.com// *reverse* order they were registered. 409013481Sgiacomo.travaglini@arm.com// 409113481Sgiacomo.travaglini@arm.com// The UnitTest object takes ownership of the given environment. 409213481Sgiacomo.travaglini@arm.com// 409313481Sgiacomo.travaglini@arm.com// We don't protect this under mutex_, as we only support calling it 409413481Sgiacomo.travaglini@arm.com// from the main thread. 409513481Sgiacomo.travaglini@arm.comEnvironment* UnitTest::AddEnvironment(Environment* env) { 409613481Sgiacomo.travaglini@arm.com if (env == NULL) { 409713481Sgiacomo.travaglini@arm.com return NULL; 409813481Sgiacomo.travaglini@arm.com } 409913481Sgiacomo.travaglini@arm.com 410013481Sgiacomo.travaglini@arm.com impl_->environments().push_back(env); 410113481Sgiacomo.travaglini@arm.com return env; 410213481Sgiacomo.travaglini@arm.com} 410313481Sgiacomo.travaglini@arm.com 410413481Sgiacomo.travaglini@arm.com// Adds a TestPartResult to the current TestResult object. All Google Test 410513481Sgiacomo.travaglini@arm.com// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call 410613481Sgiacomo.travaglini@arm.com// this to report their results. The user code should use the 410713481Sgiacomo.travaglini@arm.com// assertion macros instead of calling this directly. 410813481Sgiacomo.travaglini@arm.comvoid UnitTest::AddTestPartResult( 410913481Sgiacomo.travaglini@arm.com TestPartResult::Type result_type, 411013481Sgiacomo.travaglini@arm.com const char* file_name, 411113481Sgiacomo.travaglini@arm.com int line_number, 411213481Sgiacomo.travaglini@arm.com const std::string& message, 411313481Sgiacomo.travaglini@arm.com const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) { 411413481Sgiacomo.travaglini@arm.com Message msg; 411513481Sgiacomo.travaglini@arm.com msg << message; 411613481Sgiacomo.travaglini@arm.com 411713481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&mutex_); 411813481Sgiacomo.travaglini@arm.com if (impl_->gtest_trace_stack().size() > 0) { 411913481Sgiacomo.travaglini@arm.com msg << "\n" << GTEST_NAME_ << " trace:"; 412013481Sgiacomo.travaglini@arm.com 412113481Sgiacomo.travaglini@arm.com for (int i = static_cast<int>(impl_->gtest_trace_stack().size()); 412213481Sgiacomo.travaglini@arm.com i > 0; --i) { 412313481Sgiacomo.travaglini@arm.com const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; 412413481Sgiacomo.travaglini@arm.com msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) 412513481Sgiacomo.travaglini@arm.com << " " << trace.message; 412613481Sgiacomo.travaglini@arm.com } 412713481Sgiacomo.travaglini@arm.com } 412813481Sgiacomo.travaglini@arm.com 412913481Sgiacomo.travaglini@arm.com if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { 413013481Sgiacomo.travaglini@arm.com msg << internal::kStackTraceMarker << os_stack_trace; 413113481Sgiacomo.travaglini@arm.com } 413213481Sgiacomo.travaglini@arm.com 413313481Sgiacomo.travaglini@arm.com const TestPartResult result = 413413481Sgiacomo.travaglini@arm.com TestPartResult(result_type, file_name, line_number, 413513481Sgiacomo.travaglini@arm.com msg.GetString().c_str()); 413613481Sgiacomo.travaglini@arm.com impl_->GetTestPartResultReporterForCurrentThread()-> 413713481Sgiacomo.travaglini@arm.com ReportTestPartResult(result); 413813481Sgiacomo.travaglini@arm.com 413913481Sgiacomo.travaglini@arm.com if (result_type != TestPartResult::kSuccess) { 414013481Sgiacomo.travaglini@arm.com // gtest_break_on_failure takes precedence over 414113481Sgiacomo.travaglini@arm.com // gtest_throw_on_failure. This allows a user to set the latter 414213481Sgiacomo.travaglini@arm.com // in the code (perhaps in order to use Google Test assertions 414313481Sgiacomo.travaglini@arm.com // with another testing framework) and specify the former on the 414413481Sgiacomo.travaglini@arm.com // command line for debugging. 414513481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(break_on_failure)) { 414613481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 414713481Sgiacomo.travaglini@arm.com // Using DebugBreak on Windows allows gtest to still break into a debugger 414813481Sgiacomo.travaglini@arm.com // when a failure happens and both the --gtest_break_on_failure and 414913481Sgiacomo.travaglini@arm.com // the --gtest_catch_exceptions flags are specified. 415013481Sgiacomo.travaglini@arm.com DebugBreak(); 415113481Sgiacomo.travaglini@arm.com#else 415213481Sgiacomo.travaglini@arm.com // Dereference NULL through a volatile pointer to prevent the compiler 415313481Sgiacomo.travaglini@arm.com // from removing. We use this rather than abort() or __builtin_trap() for 415413481Sgiacomo.travaglini@arm.com // portability: Symbian doesn't implement abort() well, and some debuggers 415513481Sgiacomo.travaglini@arm.com // don't correctly trap abort(). 415613481Sgiacomo.travaglini@arm.com *static_cast<volatile int*>(NULL) = 1; 415713481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 415813481Sgiacomo.travaglini@arm.com } else if (GTEST_FLAG(throw_on_failure)) { 415913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 416013481Sgiacomo.travaglini@arm.com throw internal::GoogleTestFailureException(result); 416113481Sgiacomo.travaglini@arm.com#else 416213481Sgiacomo.travaglini@arm.com // We cannot call abort() as it generates a pop-up in debug mode 416313481Sgiacomo.travaglini@arm.com // that cannot be suppressed in VC 7.1 or below. 416413481Sgiacomo.travaglini@arm.com exit(1); 416513481Sgiacomo.travaglini@arm.com#endif 416613481Sgiacomo.travaglini@arm.com } 416713481Sgiacomo.travaglini@arm.com } 416813481Sgiacomo.travaglini@arm.com} 416913481Sgiacomo.travaglini@arm.com 417013481Sgiacomo.travaglini@arm.com// Adds a TestProperty to the current TestResult object when invoked from 417113481Sgiacomo.travaglini@arm.com// inside a test, to current TestCase's ad_hoc_test_result_ when invoked 417213481Sgiacomo.travaglini@arm.com// from SetUpTestCase or TearDownTestCase, or to the global property set 417313481Sgiacomo.travaglini@arm.com// when invoked elsewhere. If the result already contains a property with 417413481Sgiacomo.travaglini@arm.com// the same key, the value will be updated. 417513481Sgiacomo.travaglini@arm.comvoid UnitTest::RecordProperty(const std::string& key, 417613481Sgiacomo.travaglini@arm.com const std::string& value) { 417713481Sgiacomo.travaglini@arm.com impl_->RecordProperty(TestProperty(key, value)); 417813481Sgiacomo.travaglini@arm.com} 417913481Sgiacomo.travaglini@arm.com 418013481Sgiacomo.travaglini@arm.com// Runs all tests in this UnitTest object and prints the result. 418113481Sgiacomo.travaglini@arm.com// Returns 0 if successful, or 1 otherwise. 418213481Sgiacomo.travaglini@arm.com// 418313481Sgiacomo.travaglini@arm.com// We don't protect this under mutex_, as we only support calling it 418413481Sgiacomo.travaglini@arm.com// from the main thread. 418513481Sgiacomo.travaglini@arm.comint UnitTest::Run() { 418613481Sgiacomo.travaglini@arm.com const bool in_death_test_child_process = 418713481Sgiacomo.travaglini@arm.com internal::GTEST_FLAG(internal_run_death_test).length() > 0; 418813481Sgiacomo.travaglini@arm.com 418913481Sgiacomo.travaglini@arm.com // Google Test implements this protocol for catching that a test 419013481Sgiacomo.travaglini@arm.com // program exits before returning control to Google Test: 419113481Sgiacomo.travaglini@arm.com // 419213481Sgiacomo.travaglini@arm.com // 1. Upon start, Google Test creates a file whose absolute path 419313481Sgiacomo.travaglini@arm.com // is specified by the environment variable 419413481Sgiacomo.travaglini@arm.com // TEST_PREMATURE_EXIT_FILE. 419513481Sgiacomo.travaglini@arm.com // 2. When Google Test has finished its work, it deletes the file. 419613481Sgiacomo.travaglini@arm.com // 419713481Sgiacomo.travaglini@arm.com // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before 419813481Sgiacomo.travaglini@arm.com // running a Google-Test-based test program and check the existence 419913481Sgiacomo.travaglini@arm.com // of the file at the end of the test execution to see if it has 420013481Sgiacomo.travaglini@arm.com // exited prematurely. 420113481Sgiacomo.travaglini@arm.com 420213481Sgiacomo.travaglini@arm.com // If we are in the child process of a death test, don't 420313481Sgiacomo.travaglini@arm.com // create/delete the premature exit file, as doing so is unnecessary 420413481Sgiacomo.travaglini@arm.com // and will confuse the parent process. Otherwise, create/delete 420513481Sgiacomo.travaglini@arm.com // the file upon entering/leaving this function. If the program 420613481Sgiacomo.travaglini@arm.com // somehow exits before this function has a chance to return, the 420713481Sgiacomo.travaglini@arm.com // premature-exit file will be left undeleted, causing a test runner 420813481Sgiacomo.travaglini@arm.com // that understands the premature-exit-file protocol to report the 420913481Sgiacomo.travaglini@arm.com // test as having failed. 421013481Sgiacomo.travaglini@arm.com const internal::ScopedPrematureExitFile premature_exit_file( 421113481Sgiacomo.travaglini@arm.com in_death_test_child_process ? 421213481Sgiacomo.travaglini@arm.com NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); 421313481Sgiacomo.travaglini@arm.com 421413481Sgiacomo.travaglini@arm.com // Captures the value of GTEST_FLAG(catch_exceptions). This value will be 421513481Sgiacomo.travaglini@arm.com // used for the duration of the program. 421613481Sgiacomo.travaglini@arm.com impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); 421713481Sgiacomo.travaglini@arm.com 421813481Sgiacomo.travaglini@arm.com#if GTEST_HAS_SEH 421913481Sgiacomo.travaglini@arm.com // Either the user wants Google Test to catch exceptions thrown by the 422013481Sgiacomo.travaglini@arm.com // tests or this is executing in the context of death test child 422113481Sgiacomo.travaglini@arm.com // process. In either case the user does not want to see pop-up dialogs 422213481Sgiacomo.travaglini@arm.com // about crashes - they are expected. 422313481Sgiacomo.travaglini@arm.com if (impl()->catch_exceptions() || in_death_test_child_process) { 422413481Sgiacomo.travaglini@arm.com# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 422513481Sgiacomo.travaglini@arm.com // SetErrorMode doesn't exist on CE. 422613481Sgiacomo.travaglini@arm.com SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | 422713481Sgiacomo.travaglini@arm.com SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); 422813481Sgiacomo.travaglini@arm.com# endif // !GTEST_OS_WINDOWS_MOBILE 422913481Sgiacomo.travaglini@arm.com 423013481Sgiacomo.travaglini@arm.com# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE 423113481Sgiacomo.travaglini@arm.com // Death test children can be terminated with _abort(). On Windows, 423213481Sgiacomo.travaglini@arm.com // _abort() can show a dialog with a warning message. This forces the 423313481Sgiacomo.travaglini@arm.com // abort message to go to stderr instead. 423413481Sgiacomo.travaglini@arm.com _set_error_mode(_OUT_TO_STDERR); 423513481Sgiacomo.travaglini@arm.com# endif 423613481Sgiacomo.travaglini@arm.com 423713481Sgiacomo.travaglini@arm.com# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE 423813481Sgiacomo.travaglini@arm.com // In the debug version, Visual Studio pops up a separate dialog 423913481Sgiacomo.travaglini@arm.com // offering a choice to debug the aborted program. We need to suppress 424013481Sgiacomo.travaglini@arm.com // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement 424113481Sgiacomo.travaglini@arm.com // executed. Google Test will notify the user of any unexpected 424213481Sgiacomo.travaglini@arm.com // failure via stderr. 424313481Sgiacomo.travaglini@arm.com // 424413481Sgiacomo.travaglini@arm.com // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. 424513481Sgiacomo.travaglini@arm.com // Users of prior VC versions shall suffer the agony and pain of 424613481Sgiacomo.travaglini@arm.com // clicking through the countless debug dialogs. 424713481Sgiacomo.travaglini@arm.com // TODO(vladl@google.com): find a way to suppress the abort dialog() in the 424813481Sgiacomo.travaglini@arm.com // debug mode when compiled with VC 7.1 or lower. 424913481Sgiacomo.travaglini@arm.com if (!GTEST_FLAG(break_on_failure)) 425013481Sgiacomo.travaglini@arm.com _set_abort_behavior( 425113481Sgiacomo.travaglini@arm.com 0x0, // Clear the following flags: 425213481Sgiacomo.travaglini@arm.com _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. 425313481Sgiacomo.travaglini@arm.com# endif 425413481Sgiacomo.travaglini@arm.com } 425513481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_SEH 425613481Sgiacomo.travaglini@arm.com 425713481Sgiacomo.travaglini@arm.com return internal::HandleExceptionsInMethodIfSupported( 425813481Sgiacomo.travaglini@arm.com impl(), 425913481Sgiacomo.travaglini@arm.com &internal::UnitTestImpl::RunAllTests, 426013481Sgiacomo.travaglini@arm.com "auxiliary test code (environments or event listeners)") ? 0 : 1; 426113481Sgiacomo.travaglini@arm.com} 426213481Sgiacomo.travaglini@arm.com 426313481Sgiacomo.travaglini@arm.com// Returns the working directory when the first TEST() or TEST_F() was 426413481Sgiacomo.travaglini@arm.com// executed. 426513481Sgiacomo.travaglini@arm.comconst char* UnitTest::original_working_dir() const { 426613481Sgiacomo.travaglini@arm.com return impl_->original_working_dir_.c_str(); 426713481Sgiacomo.travaglini@arm.com} 426813481Sgiacomo.travaglini@arm.com 426913481Sgiacomo.travaglini@arm.com// Returns the TestCase object for the test that's currently running, 427013481Sgiacomo.travaglini@arm.com// or NULL if no test is running. 427113481Sgiacomo.travaglini@arm.comconst TestCase* UnitTest::current_test_case() const 427213481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(mutex_) { 427313481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&mutex_); 427413481Sgiacomo.travaglini@arm.com return impl_->current_test_case(); 427513481Sgiacomo.travaglini@arm.com} 427613481Sgiacomo.travaglini@arm.com 427713481Sgiacomo.travaglini@arm.com// Returns the TestInfo object for the test that's currently running, 427813481Sgiacomo.travaglini@arm.com// or NULL if no test is running. 427913481Sgiacomo.travaglini@arm.comconst TestInfo* UnitTest::current_test_info() const 428013481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(mutex_) { 428113481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&mutex_); 428213481Sgiacomo.travaglini@arm.com return impl_->current_test_info(); 428313481Sgiacomo.travaglini@arm.com} 428413481Sgiacomo.travaglini@arm.com 428513481Sgiacomo.travaglini@arm.com// Returns the random seed used at the start of the current test run. 428613481Sgiacomo.travaglini@arm.comint UnitTest::random_seed() const { return impl_->random_seed(); } 428713481Sgiacomo.travaglini@arm.com 428813481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 428913481Sgiacomo.travaglini@arm.com// Returns ParameterizedTestCaseRegistry object used to keep track of 429013481Sgiacomo.travaglini@arm.com// value-parameterized tests and instantiate and register them. 429113481Sgiacomo.travaglini@arm.cominternal::ParameterizedTestCaseRegistry& 429213481Sgiacomo.travaglini@arm.com UnitTest::parameterized_test_registry() 429313481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(mutex_) { 429413481Sgiacomo.travaglini@arm.com return impl_->parameterized_test_registry(); 429513481Sgiacomo.travaglini@arm.com} 429613481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PARAM_TEST 429713481Sgiacomo.travaglini@arm.com 429813481Sgiacomo.travaglini@arm.com// Creates an empty UnitTest. 429913481Sgiacomo.travaglini@arm.comUnitTest::UnitTest() { 430013481Sgiacomo.travaglini@arm.com impl_ = new internal::UnitTestImpl(this); 430113481Sgiacomo.travaglini@arm.com} 430213481Sgiacomo.travaglini@arm.com 430313481Sgiacomo.travaglini@arm.com// Destructor of UnitTest. 430413481Sgiacomo.travaglini@arm.comUnitTest::~UnitTest() { 430513481Sgiacomo.travaglini@arm.com delete impl_; 430613481Sgiacomo.travaglini@arm.com} 430713481Sgiacomo.travaglini@arm.com 430813481Sgiacomo.travaglini@arm.com// Pushes a trace defined by SCOPED_TRACE() on to the per-thread 430913481Sgiacomo.travaglini@arm.com// Google Test trace stack. 431013481Sgiacomo.travaglini@arm.comvoid UnitTest::PushGTestTrace(const internal::TraceInfo& trace) 431113481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(mutex_) { 431213481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&mutex_); 431313481Sgiacomo.travaglini@arm.com impl_->gtest_trace_stack().push_back(trace); 431413481Sgiacomo.travaglini@arm.com} 431513481Sgiacomo.travaglini@arm.com 431613481Sgiacomo.travaglini@arm.com// Pops a trace from the per-thread Google Test trace stack. 431713481Sgiacomo.travaglini@arm.comvoid UnitTest::PopGTestTrace() 431813481Sgiacomo.travaglini@arm.com GTEST_LOCK_EXCLUDED_(mutex_) { 431913481Sgiacomo.travaglini@arm.com internal::MutexLock lock(&mutex_); 432013481Sgiacomo.travaglini@arm.com impl_->gtest_trace_stack().pop_back(); 432113481Sgiacomo.travaglini@arm.com} 432213481Sgiacomo.travaglini@arm.com 432313481Sgiacomo.travaglini@arm.comnamespace internal { 432413481Sgiacomo.travaglini@arm.com 432513481Sgiacomo.travaglini@arm.comUnitTestImpl::UnitTestImpl(UnitTest* parent) 432613481Sgiacomo.travaglini@arm.com : parent_(parent), 432713481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */) 432813481Sgiacomo.travaglini@arm.com default_global_test_part_result_reporter_(this), 432913481Sgiacomo.travaglini@arm.com default_per_thread_test_part_result_reporter_(this), 433013481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_POP_() 433113481Sgiacomo.travaglini@arm.com global_test_part_result_repoter_( 433213481Sgiacomo.travaglini@arm.com &default_global_test_part_result_reporter_), 433313481Sgiacomo.travaglini@arm.com per_thread_test_part_result_reporter_( 433413481Sgiacomo.travaglini@arm.com &default_per_thread_test_part_result_reporter_), 433513481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 433613481Sgiacomo.travaglini@arm.com parameterized_test_registry_(), 433713481Sgiacomo.travaglini@arm.com parameterized_tests_registered_(false), 433813481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PARAM_TEST 433913481Sgiacomo.travaglini@arm.com last_death_test_case_(-1), 434013481Sgiacomo.travaglini@arm.com current_test_case_(NULL), 434113481Sgiacomo.travaglini@arm.com current_test_info_(NULL), 434213481Sgiacomo.travaglini@arm.com ad_hoc_test_result_(), 434313481Sgiacomo.travaglini@arm.com os_stack_trace_getter_(NULL), 434413481Sgiacomo.travaglini@arm.com post_flag_parse_init_performed_(false), 434513481Sgiacomo.travaglini@arm.com random_seed_(0), // Will be overridden by the flag before first use. 434613481Sgiacomo.travaglini@arm.com random_(0), // Will be reseeded before first use. 434713481Sgiacomo.travaglini@arm.com start_timestamp_(0), 434813481Sgiacomo.travaglini@arm.com elapsed_time_(0), 434913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST 435013481Sgiacomo.travaglini@arm.com death_test_factory_(new DefaultDeathTestFactory), 435113481Sgiacomo.travaglini@arm.com#endif 435213481Sgiacomo.travaglini@arm.com // Will be overridden by the flag before first use. 435313481Sgiacomo.travaglini@arm.com catch_exceptions_(false) { 435413481Sgiacomo.travaglini@arm.com listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); 435513481Sgiacomo.travaglini@arm.com} 435613481Sgiacomo.travaglini@arm.com 435713481Sgiacomo.travaglini@arm.comUnitTestImpl::~UnitTestImpl() { 435813481Sgiacomo.travaglini@arm.com // Deletes every TestCase. 435913481Sgiacomo.travaglini@arm.com ForEach(test_cases_, internal::Delete<TestCase>); 436013481Sgiacomo.travaglini@arm.com 436113481Sgiacomo.travaglini@arm.com // Deletes every Environment. 436213481Sgiacomo.travaglini@arm.com ForEach(environments_, internal::Delete<Environment>); 436313481Sgiacomo.travaglini@arm.com 436413481Sgiacomo.travaglini@arm.com delete os_stack_trace_getter_; 436513481Sgiacomo.travaglini@arm.com} 436613481Sgiacomo.travaglini@arm.com 436713481Sgiacomo.travaglini@arm.com// Adds a TestProperty to the current TestResult object when invoked in a 436813481Sgiacomo.travaglini@arm.com// context of a test, to current test case's ad_hoc_test_result when invoke 436913481Sgiacomo.travaglini@arm.com// from SetUpTestCase/TearDownTestCase, or to the global property set 437013481Sgiacomo.travaglini@arm.com// otherwise. If the result already contains a property with the same key, 437113481Sgiacomo.travaglini@arm.com// the value will be updated. 437213481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::RecordProperty(const TestProperty& test_property) { 437313481Sgiacomo.travaglini@arm.com std::string xml_element; 437413481Sgiacomo.travaglini@arm.com TestResult* test_result; // TestResult appropriate for property recording. 437513481Sgiacomo.travaglini@arm.com 437613481Sgiacomo.travaglini@arm.com if (current_test_info_ != NULL) { 437713481Sgiacomo.travaglini@arm.com xml_element = "testcase"; 437813481Sgiacomo.travaglini@arm.com test_result = &(current_test_info_->result_); 437913481Sgiacomo.travaglini@arm.com } else if (current_test_case_ != NULL) { 438013481Sgiacomo.travaglini@arm.com xml_element = "testsuite"; 438113481Sgiacomo.travaglini@arm.com test_result = &(current_test_case_->ad_hoc_test_result_); 438213481Sgiacomo.travaglini@arm.com } else { 438313481Sgiacomo.travaglini@arm.com xml_element = "testsuites"; 438413481Sgiacomo.travaglini@arm.com test_result = &ad_hoc_test_result_; 438513481Sgiacomo.travaglini@arm.com } 438613481Sgiacomo.travaglini@arm.com test_result->RecordProperty(xml_element, test_property); 438713481Sgiacomo.travaglini@arm.com} 438813481Sgiacomo.travaglini@arm.com 438913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST 439013481Sgiacomo.travaglini@arm.com// Disables event forwarding if the control is currently in a death test 439113481Sgiacomo.travaglini@arm.com// subprocess. Must not be called before InitGoogleTest. 439213481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::SuppressTestEventsIfInSubprocess() { 439313481Sgiacomo.travaglini@arm.com if (internal_run_death_test_flag_.get() != NULL) 439413481Sgiacomo.travaglini@arm.com listeners()->SuppressEventForwarding(); 439513481Sgiacomo.travaglini@arm.com} 439613481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_DEATH_TEST 439713481Sgiacomo.travaglini@arm.com 439813481Sgiacomo.travaglini@arm.com// Initializes event listeners performing XML output as specified by 439913481Sgiacomo.travaglini@arm.com// UnitTestOptions. Must not be called before InitGoogleTest. 440013481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::ConfigureXmlOutput() { 440113481Sgiacomo.travaglini@arm.com const std::string& output_format = UnitTestOptions::GetOutputFormat(); 440213481Sgiacomo.travaglini@arm.com if (output_format == "xml") { 440313481Sgiacomo.travaglini@arm.com listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( 440413481Sgiacomo.travaglini@arm.com UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); 440513481Sgiacomo.travaglini@arm.com } else if (output_format != "") { 440613481Sgiacomo.travaglini@arm.com printf("WARNING: unrecognized output format \"%s\" ignored.\n", 440713481Sgiacomo.travaglini@arm.com output_format.c_str()); 440813481Sgiacomo.travaglini@arm.com fflush(stdout); 440913481Sgiacomo.travaglini@arm.com } 441013481Sgiacomo.travaglini@arm.com} 441113481Sgiacomo.travaglini@arm.com 441213481Sgiacomo.travaglini@arm.com#if GTEST_CAN_STREAM_RESULTS_ 441313481Sgiacomo.travaglini@arm.com// Initializes event listeners for streaming test results in string form. 441413481Sgiacomo.travaglini@arm.com// Must not be called before InitGoogleTest. 441513481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::ConfigureStreamingOutput() { 441613481Sgiacomo.travaglini@arm.com const std::string& target = GTEST_FLAG(stream_result_to); 441713481Sgiacomo.travaglini@arm.com if (!target.empty()) { 441813481Sgiacomo.travaglini@arm.com const size_t pos = target.find(':'); 441913481Sgiacomo.travaglini@arm.com if (pos != std::string::npos) { 442013481Sgiacomo.travaglini@arm.com listeners()->Append(new StreamingListener(target.substr(0, pos), 442113481Sgiacomo.travaglini@arm.com target.substr(pos+1))); 442213481Sgiacomo.travaglini@arm.com } else { 442313481Sgiacomo.travaglini@arm.com printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", 442413481Sgiacomo.travaglini@arm.com target.c_str()); 442513481Sgiacomo.travaglini@arm.com fflush(stdout); 442613481Sgiacomo.travaglini@arm.com } 442713481Sgiacomo.travaglini@arm.com } 442813481Sgiacomo.travaglini@arm.com} 442913481Sgiacomo.travaglini@arm.com#endif // GTEST_CAN_STREAM_RESULTS_ 443013481Sgiacomo.travaglini@arm.com 443113481Sgiacomo.travaglini@arm.com// Performs initialization dependent upon flag values obtained in 443213481Sgiacomo.travaglini@arm.com// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to 443313481Sgiacomo.travaglini@arm.com// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest 443413481Sgiacomo.travaglini@arm.com// this function is also called from RunAllTests. Since this function can be 443513481Sgiacomo.travaglini@arm.com// called more than once, it has to be idempotent. 443613481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::PostFlagParsingInit() { 443713481Sgiacomo.travaglini@arm.com // Ensures that this function does not execute more than once. 443813481Sgiacomo.travaglini@arm.com if (!post_flag_parse_init_performed_) { 443913481Sgiacomo.travaglini@arm.com post_flag_parse_init_performed_ = true; 444013481Sgiacomo.travaglini@arm.com 444113481Sgiacomo.travaglini@arm.com#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) 444213481Sgiacomo.travaglini@arm.com // Register to send notifications about key process state changes. 444313481Sgiacomo.travaglini@arm.com listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_()); 444413481Sgiacomo.travaglini@arm.com#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) 444513481Sgiacomo.travaglini@arm.com 444613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST 444713481Sgiacomo.travaglini@arm.com InitDeathTestSubprocessControlInfo(); 444813481Sgiacomo.travaglini@arm.com SuppressTestEventsIfInSubprocess(); 444913481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_DEATH_TEST 445013481Sgiacomo.travaglini@arm.com 445113481Sgiacomo.travaglini@arm.com // Registers parameterized tests. This makes parameterized tests 445213481Sgiacomo.travaglini@arm.com // available to the UnitTest reflection API without running 445313481Sgiacomo.travaglini@arm.com // RUN_ALL_TESTS. 445413481Sgiacomo.travaglini@arm.com RegisterParameterizedTests(); 445513481Sgiacomo.travaglini@arm.com 445613481Sgiacomo.travaglini@arm.com // Configures listeners for XML output. This makes it possible for users 445713481Sgiacomo.travaglini@arm.com // to shut down the default XML output before invoking RUN_ALL_TESTS. 445813481Sgiacomo.travaglini@arm.com ConfigureXmlOutput(); 445913481Sgiacomo.travaglini@arm.com 446013481Sgiacomo.travaglini@arm.com#if GTEST_CAN_STREAM_RESULTS_ 446113481Sgiacomo.travaglini@arm.com // Configures listeners for streaming test results to the specified server. 446213481Sgiacomo.travaglini@arm.com ConfigureStreamingOutput(); 446313481Sgiacomo.travaglini@arm.com#endif // GTEST_CAN_STREAM_RESULTS_ 446413481Sgiacomo.travaglini@arm.com } 446513481Sgiacomo.travaglini@arm.com} 446613481Sgiacomo.travaglini@arm.com 446713481Sgiacomo.travaglini@arm.com// A predicate that checks the name of a TestCase against a known 446813481Sgiacomo.travaglini@arm.com// value. 446913481Sgiacomo.travaglini@arm.com// 447013481Sgiacomo.travaglini@arm.com// This is used for implementation of the UnitTest class only. We put 447113481Sgiacomo.travaglini@arm.com// it in the anonymous namespace to prevent polluting the outer 447213481Sgiacomo.travaglini@arm.com// namespace. 447313481Sgiacomo.travaglini@arm.com// 447413481Sgiacomo.travaglini@arm.com// TestCaseNameIs is copyable. 447513481Sgiacomo.travaglini@arm.comclass TestCaseNameIs { 447613481Sgiacomo.travaglini@arm.com public: 447713481Sgiacomo.travaglini@arm.com // Constructor. 447813481Sgiacomo.travaglini@arm.com explicit TestCaseNameIs(const std::string& name) 447913481Sgiacomo.travaglini@arm.com : name_(name) {} 448013481Sgiacomo.travaglini@arm.com 448113481Sgiacomo.travaglini@arm.com // Returns true iff the name of test_case matches name_. 448213481Sgiacomo.travaglini@arm.com bool operator()(const TestCase* test_case) const { 448313481Sgiacomo.travaglini@arm.com return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; 448413481Sgiacomo.travaglini@arm.com } 448513481Sgiacomo.travaglini@arm.com 448613481Sgiacomo.travaglini@arm.com private: 448713481Sgiacomo.travaglini@arm.com std::string name_; 448813481Sgiacomo.travaglini@arm.com}; 448913481Sgiacomo.travaglini@arm.com 449013481Sgiacomo.travaglini@arm.com// Finds and returns a TestCase with the given name. If one doesn't 449113481Sgiacomo.travaglini@arm.com// exist, creates one and returns it. It's the CALLER'S 449213481Sgiacomo.travaglini@arm.com// RESPONSIBILITY to ensure that this function is only called WHEN THE 449313481Sgiacomo.travaglini@arm.com// TESTS ARE NOT SHUFFLED. 449413481Sgiacomo.travaglini@arm.com// 449513481Sgiacomo.travaglini@arm.com// Arguments: 449613481Sgiacomo.travaglini@arm.com// 449713481Sgiacomo.travaglini@arm.com// test_case_name: name of the test case 449813481Sgiacomo.travaglini@arm.com// type_param: the name of the test case's type parameter, or NULL if 449913481Sgiacomo.travaglini@arm.com// this is not a typed or a type-parameterized test case. 450013481Sgiacomo.travaglini@arm.com// set_up_tc: pointer to the function that sets up the test case 450113481Sgiacomo.travaglini@arm.com// tear_down_tc: pointer to the function that tears down the test case 450213481Sgiacomo.travaglini@arm.comTestCase* UnitTestImpl::GetTestCase(const char* test_case_name, 450313481Sgiacomo.travaglini@arm.com const char* type_param, 450413481Sgiacomo.travaglini@arm.com Test::SetUpTestCaseFunc set_up_tc, 450513481Sgiacomo.travaglini@arm.com Test::TearDownTestCaseFunc tear_down_tc) { 450613481Sgiacomo.travaglini@arm.com // Can we find a TestCase with the given name? 450713481Sgiacomo.travaglini@arm.com const std::vector<TestCase*>::const_iterator test_case = 450813481Sgiacomo.travaglini@arm.com std::find_if(test_cases_.begin(), test_cases_.end(), 450913481Sgiacomo.travaglini@arm.com TestCaseNameIs(test_case_name)); 451013481Sgiacomo.travaglini@arm.com 451113481Sgiacomo.travaglini@arm.com if (test_case != test_cases_.end()) 451213481Sgiacomo.travaglini@arm.com return *test_case; 451313481Sgiacomo.travaglini@arm.com 451413481Sgiacomo.travaglini@arm.com // No. Let's create one. 451513481Sgiacomo.travaglini@arm.com TestCase* const new_test_case = 451613481Sgiacomo.travaglini@arm.com new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); 451713481Sgiacomo.travaglini@arm.com 451813481Sgiacomo.travaglini@arm.com // Is this a death test case? 451913481Sgiacomo.travaglini@arm.com if (internal::UnitTestOptions::MatchesFilter(test_case_name, 452013481Sgiacomo.travaglini@arm.com kDeathTestCaseFilter)) { 452113481Sgiacomo.travaglini@arm.com // Yes. Inserts the test case after the last death test case 452213481Sgiacomo.travaglini@arm.com // defined so far. This only works when the test cases haven't 452313481Sgiacomo.travaglini@arm.com // been shuffled. Otherwise we may end up running a death test 452413481Sgiacomo.travaglini@arm.com // after a non-death test. 452513481Sgiacomo.travaglini@arm.com ++last_death_test_case_; 452613481Sgiacomo.travaglini@arm.com test_cases_.insert(test_cases_.begin() + last_death_test_case_, 452713481Sgiacomo.travaglini@arm.com new_test_case); 452813481Sgiacomo.travaglini@arm.com } else { 452913481Sgiacomo.travaglini@arm.com // No. Appends to the end of the list. 453013481Sgiacomo.travaglini@arm.com test_cases_.push_back(new_test_case); 453113481Sgiacomo.travaglini@arm.com } 453213481Sgiacomo.travaglini@arm.com 453313481Sgiacomo.travaglini@arm.com test_case_indices_.push_back(static_cast<int>(test_case_indices_.size())); 453413481Sgiacomo.travaglini@arm.com return new_test_case; 453513481Sgiacomo.travaglini@arm.com} 453613481Sgiacomo.travaglini@arm.com 453713481Sgiacomo.travaglini@arm.com// Helpers for setting up / tearing down the given environment. They 453813481Sgiacomo.travaglini@arm.com// are for use in the ForEach() function. 453913481Sgiacomo.travaglini@arm.comstatic void SetUpEnvironment(Environment* env) { env->SetUp(); } 454013481Sgiacomo.travaglini@arm.comstatic void TearDownEnvironment(Environment* env) { env->TearDown(); } 454113481Sgiacomo.travaglini@arm.com 454213481Sgiacomo.travaglini@arm.com// Runs all tests in this UnitTest object, prints the result, and 454313481Sgiacomo.travaglini@arm.com// returns true if all tests are successful. If any exception is 454413481Sgiacomo.travaglini@arm.com// thrown during a test, the test is considered to be failed, but the 454513481Sgiacomo.travaglini@arm.com// rest of the tests will still be run. 454613481Sgiacomo.travaglini@arm.com// 454713481Sgiacomo.travaglini@arm.com// When parameterized tests are enabled, it expands and registers 454813481Sgiacomo.travaglini@arm.com// parameterized tests first in RegisterParameterizedTests(). 454913481Sgiacomo.travaglini@arm.com// All other functions called from RunAllTests() may safely assume that 455013481Sgiacomo.travaglini@arm.com// parameterized tests are ready to be counted and run. 455113481Sgiacomo.travaglini@arm.combool UnitTestImpl::RunAllTests() { 455213481Sgiacomo.travaglini@arm.com // Makes sure InitGoogleTest() was called. 455313481Sgiacomo.travaglini@arm.com if (!GTestIsInitialized()) { 455413481Sgiacomo.travaglini@arm.com printf("%s", 455513481Sgiacomo.travaglini@arm.com "\nThis test program did NOT call ::testing::InitGoogleTest " 455613481Sgiacomo.travaglini@arm.com "before calling RUN_ALL_TESTS(). Please fix it.\n"); 455713481Sgiacomo.travaglini@arm.com return false; 455813481Sgiacomo.travaglini@arm.com } 455913481Sgiacomo.travaglini@arm.com 456013481Sgiacomo.travaglini@arm.com // Do not run any test if the --help flag was specified. 456113481Sgiacomo.travaglini@arm.com if (g_help_flag) 456213481Sgiacomo.travaglini@arm.com return true; 456313481Sgiacomo.travaglini@arm.com 456413481Sgiacomo.travaglini@arm.com // Repeats the call to the post-flag parsing initialization in case the 456513481Sgiacomo.travaglini@arm.com // user didn't call InitGoogleTest. 456613481Sgiacomo.travaglini@arm.com PostFlagParsingInit(); 456713481Sgiacomo.travaglini@arm.com 456813481Sgiacomo.travaglini@arm.com // Even if sharding is not on, test runners may want to use the 456913481Sgiacomo.travaglini@arm.com // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding 457013481Sgiacomo.travaglini@arm.com // protocol. 457113481Sgiacomo.travaglini@arm.com internal::WriteToShardStatusFileIfNeeded(); 457213481Sgiacomo.travaglini@arm.com 457313481Sgiacomo.travaglini@arm.com // True iff we are in a subprocess for running a thread-safe-style 457413481Sgiacomo.travaglini@arm.com // death test. 457513481Sgiacomo.travaglini@arm.com bool in_subprocess_for_death_test = false; 457613481Sgiacomo.travaglini@arm.com 457713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST 457813481Sgiacomo.travaglini@arm.com in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); 457913481Sgiacomo.travaglini@arm.com# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) 458013481Sgiacomo.travaglini@arm.com if (in_subprocess_for_death_test) { 458113481Sgiacomo.travaglini@arm.com GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_(); 458213481Sgiacomo.travaglini@arm.com } 458313481Sgiacomo.travaglini@arm.com# endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) 458413481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_DEATH_TEST 458513481Sgiacomo.travaglini@arm.com 458613481Sgiacomo.travaglini@arm.com const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, 458713481Sgiacomo.travaglini@arm.com in_subprocess_for_death_test); 458813481Sgiacomo.travaglini@arm.com 458913481Sgiacomo.travaglini@arm.com // Compares the full test names with the filter to decide which 459013481Sgiacomo.travaglini@arm.com // tests to run. 459113481Sgiacomo.travaglini@arm.com const bool has_tests_to_run = FilterTests(should_shard 459213481Sgiacomo.travaglini@arm.com ? HONOR_SHARDING_PROTOCOL 459313481Sgiacomo.travaglini@arm.com : IGNORE_SHARDING_PROTOCOL) > 0; 459413481Sgiacomo.travaglini@arm.com 459513481Sgiacomo.travaglini@arm.com // Lists the tests and exits if the --gtest_list_tests flag was specified. 459613481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(list_tests)) { 459713481Sgiacomo.travaglini@arm.com // This must be called *after* FilterTests() has been called. 459813481Sgiacomo.travaglini@arm.com ListTestsMatchingFilter(); 459913481Sgiacomo.travaglini@arm.com return true; 460013481Sgiacomo.travaglini@arm.com } 460113481Sgiacomo.travaglini@arm.com 460213481Sgiacomo.travaglini@arm.com random_seed_ = GTEST_FLAG(shuffle) ? 460313481Sgiacomo.travaglini@arm.com GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; 460413481Sgiacomo.travaglini@arm.com 460513481Sgiacomo.travaglini@arm.com // True iff at least one test has failed. 460613481Sgiacomo.travaglini@arm.com bool failed = false; 460713481Sgiacomo.travaglini@arm.com 460813481Sgiacomo.travaglini@arm.com TestEventListener* repeater = listeners()->repeater(); 460913481Sgiacomo.travaglini@arm.com 461013481Sgiacomo.travaglini@arm.com start_timestamp_ = GetTimeInMillis(); 461113481Sgiacomo.travaglini@arm.com repeater->OnTestProgramStart(*parent_); 461213481Sgiacomo.travaglini@arm.com 461313481Sgiacomo.travaglini@arm.com // How many times to repeat the tests? We don't want to repeat them 461413481Sgiacomo.travaglini@arm.com // when we are inside the subprocess of a death test. 461513481Sgiacomo.travaglini@arm.com const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); 461613481Sgiacomo.travaglini@arm.com // Repeats forever if the repeat count is negative. 461713481Sgiacomo.travaglini@arm.com const bool forever = repeat < 0; 461813481Sgiacomo.travaglini@arm.com for (int i = 0; forever || i != repeat; i++) { 461913481Sgiacomo.travaglini@arm.com // We want to preserve failures generated by ad-hoc test 462013481Sgiacomo.travaglini@arm.com // assertions executed before RUN_ALL_TESTS(). 462113481Sgiacomo.travaglini@arm.com ClearNonAdHocTestResult(); 462213481Sgiacomo.travaglini@arm.com 462313481Sgiacomo.travaglini@arm.com const TimeInMillis start = GetTimeInMillis(); 462413481Sgiacomo.travaglini@arm.com 462513481Sgiacomo.travaglini@arm.com // Shuffles test cases and tests if requested. 462613481Sgiacomo.travaglini@arm.com if (has_tests_to_run && GTEST_FLAG(shuffle)) { 462713481Sgiacomo.travaglini@arm.com random()->Reseed(random_seed_); 462813481Sgiacomo.travaglini@arm.com // This should be done before calling OnTestIterationStart(), 462913481Sgiacomo.travaglini@arm.com // such that a test event listener can see the actual test order 463013481Sgiacomo.travaglini@arm.com // in the event. 463113481Sgiacomo.travaglini@arm.com ShuffleTests(); 463213481Sgiacomo.travaglini@arm.com } 463313481Sgiacomo.travaglini@arm.com 463413481Sgiacomo.travaglini@arm.com // Tells the unit test event listeners that the tests are about to start. 463513481Sgiacomo.travaglini@arm.com repeater->OnTestIterationStart(*parent_, i); 463613481Sgiacomo.travaglini@arm.com 463713481Sgiacomo.travaglini@arm.com // Runs each test case if there is at least one test to run. 463813481Sgiacomo.travaglini@arm.com if (has_tests_to_run) { 463913481Sgiacomo.travaglini@arm.com // Sets up all environments beforehand. 464013481Sgiacomo.travaglini@arm.com repeater->OnEnvironmentsSetUpStart(*parent_); 464113481Sgiacomo.travaglini@arm.com ForEach(environments_, SetUpEnvironment); 464213481Sgiacomo.travaglini@arm.com repeater->OnEnvironmentsSetUpEnd(*parent_); 464313481Sgiacomo.travaglini@arm.com 464413481Sgiacomo.travaglini@arm.com // Runs the tests only if there was no fatal failure during global 464513481Sgiacomo.travaglini@arm.com // set-up. 464613481Sgiacomo.travaglini@arm.com if (!Test::HasFatalFailure()) { 464713481Sgiacomo.travaglini@arm.com for (int test_index = 0; test_index < total_test_case_count(); 464813481Sgiacomo.travaglini@arm.com test_index++) { 464913481Sgiacomo.travaglini@arm.com GetMutableTestCase(test_index)->Run(); 465013481Sgiacomo.travaglini@arm.com } 465113481Sgiacomo.travaglini@arm.com } 465213481Sgiacomo.travaglini@arm.com 465313481Sgiacomo.travaglini@arm.com // Tears down all environments in reverse order afterwards. 465413481Sgiacomo.travaglini@arm.com repeater->OnEnvironmentsTearDownStart(*parent_); 465513481Sgiacomo.travaglini@arm.com std::for_each(environments_.rbegin(), environments_.rend(), 465613481Sgiacomo.travaglini@arm.com TearDownEnvironment); 465713481Sgiacomo.travaglini@arm.com repeater->OnEnvironmentsTearDownEnd(*parent_); 465813481Sgiacomo.travaglini@arm.com } 465913481Sgiacomo.travaglini@arm.com 466013481Sgiacomo.travaglini@arm.com elapsed_time_ = GetTimeInMillis() - start; 466113481Sgiacomo.travaglini@arm.com 466213481Sgiacomo.travaglini@arm.com // Tells the unit test event listener that the tests have just finished. 466313481Sgiacomo.travaglini@arm.com repeater->OnTestIterationEnd(*parent_, i); 466413481Sgiacomo.travaglini@arm.com 466513481Sgiacomo.travaglini@arm.com // Gets the result and clears it. 466613481Sgiacomo.travaglini@arm.com if (!Passed()) { 466713481Sgiacomo.travaglini@arm.com failed = true; 466813481Sgiacomo.travaglini@arm.com } 466913481Sgiacomo.travaglini@arm.com 467013481Sgiacomo.travaglini@arm.com // Restores the original test order after the iteration. This 467113481Sgiacomo.travaglini@arm.com // allows the user to quickly repro a failure that happens in the 467213481Sgiacomo.travaglini@arm.com // N-th iteration without repeating the first (N - 1) iterations. 467313481Sgiacomo.travaglini@arm.com // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in 467413481Sgiacomo.travaglini@arm.com // case the user somehow changes the value of the flag somewhere 467513481Sgiacomo.travaglini@arm.com // (it's always safe to unshuffle the tests). 467613481Sgiacomo.travaglini@arm.com UnshuffleTests(); 467713481Sgiacomo.travaglini@arm.com 467813481Sgiacomo.travaglini@arm.com if (GTEST_FLAG(shuffle)) { 467913481Sgiacomo.travaglini@arm.com // Picks a new random seed for each iteration. 468013481Sgiacomo.travaglini@arm.com random_seed_ = GetNextRandomSeed(random_seed_); 468113481Sgiacomo.travaglini@arm.com } 468213481Sgiacomo.travaglini@arm.com } 468313481Sgiacomo.travaglini@arm.com 468413481Sgiacomo.travaglini@arm.com repeater->OnTestProgramEnd(*parent_); 468513481Sgiacomo.travaglini@arm.com 468613481Sgiacomo.travaglini@arm.com return !failed; 468713481Sgiacomo.travaglini@arm.com} 468813481Sgiacomo.travaglini@arm.com 468913481Sgiacomo.travaglini@arm.com// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file 469013481Sgiacomo.travaglini@arm.com// if the variable is present. If a file already exists at this location, this 469113481Sgiacomo.travaglini@arm.com// function will write over it. If the variable is present, but the file cannot 469213481Sgiacomo.travaglini@arm.com// be created, prints an error and exits. 469313481Sgiacomo.travaglini@arm.comvoid WriteToShardStatusFileIfNeeded() { 469413481Sgiacomo.travaglini@arm.com const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); 469513481Sgiacomo.travaglini@arm.com if (test_shard_file != NULL) { 469613481Sgiacomo.travaglini@arm.com FILE* const file = posix::FOpen(test_shard_file, "w"); 469713481Sgiacomo.travaglini@arm.com if (file == NULL) { 469813481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, 469913481Sgiacomo.travaglini@arm.com "Could not write to the test shard status file \"%s\" " 470013481Sgiacomo.travaglini@arm.com "specified by the %s environment variable.\n", 470113481Sgiacomo.travaglini@arm.com test_shard_file, kTestShardStatusFile); 470213481Sgiacomo.travaglini@arm.com fflush(stdout); 470313481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 470413481Sgiacomo.travaglini@arm.com } 470513481Sgiacomo.travaglini@arm.com fclose(file); 470613481Sgiacomo.travaglini@arm.com } 470713481Sgiacomo.travaglini@arm.com} 470813481Sgiacomo.travaglini@arm.com 470913481Sgiacomo.travaglini@arm.com// Checks whether sharding is enabled by examining the relevant 471013481Sgiacomo.travaglini@arm.com// environment variable values. If the variables are present, 471113481Sgiacomo.travaglini@arm.com// but inconsistent (i.e., shard_index >= total_shards), prints 471213481Sgiacomo.travaglini@arm.com// an error and exits. If in_subprocess_for_death_test, sharding is 471313481Sgiacomo.travaglini@arm.com// disabled because it must only be applied to the original test 471413481Sgiacomo.travaglini@arm.com// process. Otherwise, we could filter out death tests we intended to execute. 471513481Sgiacomo.travaglini@arm.combool ShouldShard(const char* total_shards_env, 471613481Sgiacomo.travaglini@arm.com const char* shard_index_env, 471713481Sgiacomo.travaglini@arm.com bool in_subprocess_for_death_test) { 471813481Sgiacomo.travaglini@arm.com if (in_subprocess_for_death_test) { 471913481Sgiacomo.travaglini@arm.com return false; 472013481Sgiacomo.travaglini@arm.com } 472113481Sgiacomo.travaglini@arm.com 472213481Sgiacomo.travaglini@arm.com const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); 472313481Sgiacomo.travaglini@arm.com const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); 472413481Sgiacomo.travaglini@arm.com 472513481Sgiacomo.travaglini@arm.com if (total_shards == -1 && shard_index == -1) { 472613481Sgiacomo.travaglini@arm.com return false; 472713481Sgiacomo.travaglini@arm.com } else if (total_shards == -1 && shard_index != -1) { 472813481Sgiacomo.travaglini@arm.com const Message msg = Message() 472913481Sgiacomo.travaglini@arm.com << "Invalid environment variables: you have " 473013481Sgiacomo.travaglini@arm.com << kTestShardIndex << " = " << shard_index 473113481Sgiacomo.travaglini@arm.com << ", but have left " << kTestTotalShards << " unset.\n"; 473213481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 473313481Sgiacomo.travaglini@arm.com fflush(stdout); 473413481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 473513481Sgiacomo.travaglini@arm.com } else if (total_shards != -1 && shard_index == -1) { 473613481Sgiacomo.travaglini@arm.com const Message msg = Message() 473713481Sgiacomo.travaglini@arm.com << "Invalid environment variables: you have " 473813481Sgiacomo.travaglini@arm.com << kTestTotalShards << " = " << total_shards 473913481Sgiacomo.travaglini@arm.com << ", but have left " << kTestShardIndex << " unset.\n"; 474013481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 474113481Sgiacomo.travaglini@arm.com fflush(stdout); 474213481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 474313481Sgiacomo.travaglini@arm.com } else if (shard_index < 0 || shard_index >= total_shards) { 474413481Sgiacomo.travaglini@arm.com const Message msg = Message() 474513481Sgiacomo.travaglini@arm.com << "Invalid environment variables: we require 0 <= " 474613481Sgiacomo.travaglini@arm.com << kTestShardIndex << " < " << kTestTotalShards 474713481Sgiacomo.travaglini@arm.com << ", but you have " << kTestShardIndex << "=" << shard_index 474813481Sgiacomo.travaglini@arm.com << ", " << kTestTotalShards << "=" << total_shards << ".\n"; 474913481Sgiacomo.travaglini@arm.com ColoredPrintf(COLOR_RED, msg.GetString().c_str()); 475013481Sgiacomo.travaglini@arm.com fflush(stdout); 475113481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 475213481Sgiacomo.travaglini@arm.com } 475313481Sgiacomo.travaglini@arm.com 475413481Sgiacomo.travaglini@arm.com return total_shards > 1; 475513481Sgiacomo.travaglini@arm.com} 475613481Sgiacomo.travaglini@arm.com 475713481Sgiacomo.travaglini@arm.com// Parses the environment variable var as an Int32. If it is unset, 475813481Sgiacomo.travaglini@arm.com// returns default_val. If it is not an Int32, prints an error 475913481Sgiacomo.travaglini@arm.com// and aborts. 476013481Sgiacomo.travaglini@arm.comInt32 Int32FromEnvOrDie(const char* var, Int32 default_val) { 476113481Sgiacomo.travaglini@arm.com const char* str_val = posix::GetEnv(var); 476213481Sgiacomo.travaglini@arm.com if (str_val == NULL) { 476313481Sgiacomo.travaglini@arm.com return default_val; 476413481Sgiacomo.travaglini@arm.com } 476513481Sgiacomo.travaglini@arm.com 476613481Sgiacomo.travaglini@arm.com Int32 result; 476713481Sgiacomo.travaglini@arm.com if (!ParseInt32(Message() << "The value of environment variable " << var, 476813481Sgiacomo.travaglini@arm.com str_val, &result)) { 476913481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 477013481Sgiacomo.travaglini@arm.com } 477113481Sgiacomo.travaglini@arm.com return result; 477213481Sgiacomo.travaglini@arm.com} 477313481Sgiacomo.travaglini@arm.com 477413481Sgiacomo.travaglini@arm.com// Given the total number of shards, the shard index, and the test id, 477513481Sgiacomo.travaglini@arm.com// returns true iff the test should be run on this shard. The test id is 477613481Sgiacomo.travaglini@arm.com// some arbitrary but unique non-negative integer assigned to each test 477713481Sgiacomo.travaglini@arm.com// method. Assumes that 0 <= shard_index < total_shards. 477813481Sgiacomo.travaglini@arm.combool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { 477913481Sgiacomo.travaglini@arm.com return (test_id % total_shards) == shard_index; 478013481Sgiacomo.travaglini@arm.com} 478113481Sgiacomo.travaglini@arm.com 478213481Sgiacomo.travaglini@arm.com// Compares the name of each test with the user-specified filter to 478313481Sgiacomo.travaglini@arm.com// decide whether the test should be run, then records the result in 478413481Sgiacomo.travaglini@arm.com// each TestCase and TestInfo object. 478513481Sgiacomo.travaglini@arm.com// If shard_tests == true, further filters tests based on sharding 478613481Sgiacomo.travaglini@arm.com// variables in the environment - see 478713481Sgiacomo.travaglini@arm.com// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. 478813481Sgiacomo.travaglini@arm.com// Returns the number of tests that should run. 478913481Sgiacomo.travaglini@arm.comint UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { 479013481Sgiacomo.travaglini@arm.com const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? 479113481Sgiacomo.travaglini@arm.com Int32FromEnvOrDie(kTestTotalShards, -1) : -1; 479213481Sgiacomo.travaglini@arm.com const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? 479313481Sgiacomo.travaglini@arm.com Int32FromEnvOrDie(kTestShardIndex, -1) : -1; 479413481Sgiacomo.travaglini@arm.com 479513481Sgiacomo.travaglini@arm.com // num_runnable_tests are the number of tests that will 479613481Sgiacomo.travaglini@arm.com // run across all shards (i.e., match filter and are not disabled). 479713481Sgiacomo.travaglini@arm.com // num_selected_tests are the number of tests to be run on 479813481Sgiacomo.travaglini@arm.com // this shard. 479913481Sgiacomo.travaglini@arm.com int num_runnable_tests = 0; 480013481Sgiacomo.travaglini@arm.com int num_selected_tests = 0; 480113481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < test_cases_.size(); i++) { 480213481Sgiacomo.travaglini@arm.com TestCase* const test_case = test_cases_[i]; 480313481Sgiacomo.travaglini@arm.com const std::string &test_case_name = test_case->name(); 480413481Sgiacomo.travaglini@arm.com test_case->set_should_run(false); 480513481Sgiacomo.travaglini@arm.com 480613481Sgiacomo.travaglini@arm.com for (size_t j = 0; j < test_case->test_info_list().size(); j++) { 480713481Sgiacomo.travaglini@arm.com TestInfo* const test_info = test_case->test_info_list()[j]; 480813481Sgiacomo.travaglini@arm.com const std::string test_name(test_info->name()); 480913481Sgiacomo.travaglini@arm.com // A test is disabled if test case name or test name matches 481013481Sgiacomo.travaglini@arm.com // kDisableTestFilter. 481113481Sgiacomo.travaglini@arm.com const bool is_disabled = 481213481Sgiacomo.travaglini@arm.com internal::UnitTestOptions::MatchesFilter(test_case_name, 481313481Sgiacomo.travaglini@arm.com kDisableTestFilter) || 481413481Sgiacomo.travaglini@arm.com internal::UnitTestOptions::MatchesFilter(test_name, 481513481Sgiacomo.travaglini@arm.com kDisableTestFilter); 481613481Sgiacomo.travaglini@arm.com test_info->is_disabled_ = is_disabled; 481713481Sgiacomo.travaglini@arm.com 481813481Sgiacomo.travaglini@arm.com const bool matches_filter = 481913481Sgiacomo.travaglini@arm.com internal::UnitTestOptions::FilterMatchesTest(test_case_name, 482013481Sgiacomo.travaglini@arm.com test_name); 482113481Sgiacomo.travaglini@arm.com test_info->matches_filter_ = matches_filter; 482213481Sgiacomo.travaglini@arm.com 482313481Sgiacomo.travaglini@arm.com const bool is_runnable = 482413481Sgiacomo.travaglini@arm.com (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && 482513481Sgiacomo.travaglini@arm.com matches_filter; 482613481Sgiacomo.travaglini@arm.com 482713481Sgiacomo.travaglini@arm.com const bool is_selected = is_runnable && 482813481Sgiacomo.travaglini@arm.com (shard_tests == IGNORE_SHARDING_PROTOCOL || 482913481Sgiacomo.travaglini@arm.com ShouldRunTestOnShard(total_shards, shard_index, 483013481Sgiacomo.travaglini@arm.com num_runnable_tests)); 483113481Sgiacomo.travaglini@arm.com 483213481Sgiacomo.travaglini@arm.com num_runnable_tests += is_runnable; 483313481Sgiacomo.travaglini@arm.com num_selected_tests += is_selected; 483413481Sgiacomo.travaglini@arm.com 483513481Sgiacomo.travaglini@arm.com test_info->should_run_ = is_selected; 483613481Sgiacomo.travaglini@arm.com test_case->set_should_run(test_case->should_run() || is_selected); 483713481Sgiacomo.travaglini@arm.com } 483813481Sgiacomo.travaglini@arm.com } 483913481Sgiacomo.travaglini@arm.com return num_selected_tests; 484013481Sgiacomo.travaglini@arm.com} 484113481Sgiacomo.travaglini@arm.com 484213481Sgiacomo.travaglini@arm.com// Prints the given C-string on a single line by replacing all '\n' 484313481Sgiacomo.travaglini@arm.com// characters with string "\\n". If the output takes more than 484413481Sgiacomo.travaglini@arm.com// max_length characters, only prints the first max_length characters 484513481Sgiacomo.travaglini@arm.com// and "...". 484613481Sgiacomo.travaglini@arm.comstatic void PrintOnOneLine(const char* str, int max_length) { 484713481Sgiacomo.travaglini@arm.com if (str != NULL) { 484813481Sgiacomo.travaglini@arm.com for (int i = 0; *str != '\0'; ++str) { 484913481Sgiacomo.travaglini@arm.com if (i >= max_length) { 485013481Sgiacomo.travaglini@arm.com printf("..."); 485113481Sgiacomo.travaglini@arm.com break; 485213481Sgiacomo.travaglini@arm.com } 485313481Sgiacomo.travaglini@arm.com if (*str == '\n') { 485413481Sgiacomo.travaglini@arm.com printf("\\n"); 485513481Sgiacomo.travaglini@arm.com i += 2; 485613481Sgiacomo.travaglini@arm.com } else { 485713481Sgiacomo.travaglini@arm.com printf("%c", *str); 485813481Sgiacomo.travaglini@arm.com ++i; 485913481Sgiacomo.travaglini@arm.com } 486013481Sgiacomo.travaglini@arm.com } 486113481Sgiacomo.travaglini@arm.com } 486213481Sgiacomo.travaglini@arm.com} 486313481Sgiacomo.travaglini@arm.com 486413481Sgiacomo.travaglini@arm.com// Prints the names of the tests matching the user-specified filter flag. 486513481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::ListTestsMatchingFilter() { 486613481Sgiacomo.travaglini@arm.com // Print at most this many characters for each type/value parameter. 486713481Sgiacomo.travaglini@arm.com const int kMaxParamLength = 250; 486813481Sgiacomo.travaglini@arm.com 486913481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < test_cases_.size(); i++) { 487013481Sgiacomo.travaglini@arm.com const TestCase* const test_case = test_cases_[i]; 487113481Sgiacomo.travaglini@arm.com bool printed_test_case_name = false; 487213481Sgiacomo.travaglini@arm.com 487313481Sgiacomo.travaglini@arm.com for (size_t j = 0; j < test_case->test_info_list().size(); j++) { 487413481Sgiacomo.travaglini@arm.com const TestInfo* const test_info = 487513481Sgiacomo.travaglini@arm.com test_case->test_info_list()[j]; 487613481Sgiacomo.travaglini@arm.com if (test_info->matches_filter_) { 487713481Sgiacomo.travaglini@arm.com if (!printed_test_case_name) { 487813481Sgiacomo.travaglini@arm.com printed_test_case_name = true; 487913481Sgiacomo.travaglini@arm.com printf("%s.", test_case->name()); 488013481Sgiacomo.travaglini@arm.com if (test_case->type_param() != NULL) { 488113481Sgiacomo.travaglini@arm.com printf(" # %s = ", kTypeParamLabel); 488213481Sgiacomo.travaglini@arm.com // We print the type parameter on a single line to make 488313481Sgiacomo.travaglini@arm.com // the output easy to parse by a program. 488413481Sgiacomo.travaglini@arm.com PrintOnOneLine(test_case->type_param(), kMaxParamLength); 488513481Sgiacomo.travaglini@arm.com } 488613481Sgiacomo.travaglini@arm.com printf("\n"); 488713481Sgiacomo.travaglini@arm.com } 488813481Sgiacomo.travaglini@arm.com printf(" %s", test_info->name()); 488913481Sgiacomo.travaglini@arm.com if (test_info->value_param() != NULL) { 489013481Sgiacomo.travaglini@arm.com printf(" # %s = ", kValueParamLabel); 489113481Sgiacomo.travaglini@arm.com // We print the value parameter on a single line to make the 489213481Sgiacomo.travaglini@arm.com // output easy to parse by a program. 489313481Sgiacomo.travaglini@arm.com PrintOnOneLine(test_info->value_param(), kMaxParamLength); 489413481Sgiacomo.travaglini@arm.com } 489513481Sgiacomo.travaglini@arm.com printf("\n"); 489613481Sgiacomo.travaglini@arm.com } 489713481Sgiacomo.travaglini@arm.com } 489813481Sgiacomo.travaglini@arm.com } 489913481Sgiacomo.travaglini@arm.com fflush(stdout); 490013481Sgiacomo.travaglini@arm.com} 490113481Sgiacomo.travaglini@arm.com 490213481Sgiacomo.travaglini@arm.com// Sets the OS stack trace getter. 490313481Sgiacomo.travaglini@arm.com// 490413481Sgiacomo.travaglini@arm.com// Does nothing if the input and the current OS stack trace getter are 490513481Sgiacomo.travaglini@arm.com// the same; otherwise, deletes the old getter and makes the input the 490613481Sgiacomo.travaglini@arm.com// current getter. 490713481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::set_os_stack_trace_getter( 490813481Sgiacomo.travaglini@arm.com OsStackTraceGetterInterface* getter) { 490913481Sgiacomo.travaglini@arm.com if (os_stack_trace_getter_ != getter) { 491013481Sgiacomo.travaglini@arm.com delete os_stack_trace_getter_; 491113481Sgiacomo.travaglini@arm.com os_stack_trace_getter_ = getter; 491213481Sgiacomo.travaglini@arm.com } 491313481Sgiacomo.travaglini@arm.com} 491413481Sgiacomo.travaglini@arm.com 491513481Sgiacomo.travaglini@arm.com// Returns the current OS stack trace getter if it is not NULL; 491613481Sgiacomo.travaglini@arm.com// otherwise, creates an OsStackTraceGetter, makes it the current 491713481Sgiacomo.travaglini@arm.com// getter, and returns it. 491813481Sgiacomo.travaglini@arm.comOsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { 491913481Sgiacomo.travaglini@arm.com if (os_stack_trace_getter_ == NULL) { 492013481Sgiacomo.travaglini@arm.com#ifdef GTEST_OS_STACK_TRACE_GETTER_ 492113481Sgiacomo.travaglini@arm.com os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_; 492213481Sgiacomo.travaglini@arm.com#else 492313481Sgiacomo.travaglini@arm.com os_stack_trace_getter_ = new OsStackTraceGetter; 492413481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_STACK_TRACE_GETTER_ 492513481Sgiacomo.travaglini@arm.com } 492613481Sgiacomo.travaglini@arm.com 492713481Sgiacomo.travaglini@arm.com return os_stack_trace_getter_; 492813481Sgiacomo.travaglini@arm.com} 492913481Sgiacomo.travaglini@arm.com 493013481Sgiacomo.travaglini@arm.com// Returns the TestResult for the test that's currently running, or 493113481Sgiacomo.travaglini@arm.com// the TestResult for the ad hoc test if no test is running. 493213481Sgiacomo.travaglini@arm.comTestResult* UnitTestImpl::current_test_result() { 493313481Sgiacomo.travaglini@arm.com return current_test_info_ ? 493413481Sgiacomo.travaglini@arm.com &(current_test_info_->result_) : &ad_hoc_test_result_; 493513481Sgiacomo.travaglini@arm.com} 493613481Sgiacomo.travaglini@arm.com 493713481Sgiacomo.travaglini@arm.com// Shuffles all test cases, and the tests within each test case, 493813481Sgiacomo.travaglini@arm.com// making sure that death tests are still run first. 493913481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::ShuffleTests() { 494013481Sgiacomo.travaglini@arm.com // Shuffles the death test cases. 494113481Sgiacomo.travaglini@arm.com ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); 494213481Sgiacomo.travaglini@arm.com 494313481Sgiacomo.travaglini@arm.com // Shuffles the non-death test cases. 494413481Sgiacomo.travaglini@arm.com ShuffleRange(random(), last_death_test_case_ + 1, 494513481Sgiacomo.travaglini@arm.com static_cast<int>(test_cases_.size()), &test_case_indices_); 494613481Sgiacomo.travaglini@arm.com 494713481Sgiacomo.travaglini@arm.com // Shuffles the tests inside each test case. 494813481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < test_cases_.size(); i++) { 494913481Sgiacomo.travaglini@arm.com test_cases_[i]->ShuffleTests(random()); 495013481Sgiacomo.travaglini@arm.com } 495113481Sgiacomo.travaglini@arm.com} 495213481Sgiacomo.travaglini@arm.com 495313481Sgiacomo.travaglini@arm.com// Restores the test cases and tests to their order before the first shuffle. 495413481Sgiacomo.travaglini@arm.comvoid UnitTestImpl::UnshuffleTests() { 495513481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < test_cases_.size(); i++) { 495613481Sgiacomo.travaglini@arm.com // Unshuffles the tests in each test case. 495713481Sgiacomo.travaglini@arm.com test_cases_[i]->UnshuffleTests(); 495813481Sgiacomo.travaglini@arm.com // Resets the index of each test case. 495913481Sgiacomo.travaglini@arm.com test_case_indices_[i] = static_cast<int>(i); 496013481Sgiacomo.travaglini@arm.com } 496113481Sgiacomo.travaglini@arm.com} 496213481Sgiacomo.travaglini@arm.com 496313481Sgiacomo.travaglini@arm.com// Returns the current OS stack trace as an std::string. 496413481Sgiacomo.travaglini@arm.com// 496513481Sgiacomo.travaglini@arm.com// The maximum number of stack frames to be included is specified by 496613481Sgiacomo.travaglini@arm.com// the gtest_stack_trace_depth flag. The skip_count parameter 496713481Sgiacomo.travaglini@arm.com// specifies the number of top frames to be skipped, which doesn't 496813481Sgiacomo.travaglini@arm.com// count against the number of frames to be included. 496913481Sgiacomo.travaglini@arm.com// 497013481Sgiacomo.travaglini@arm.com// For example, if Foo() calls Bar(), which in turn calls 497113481Sgiacomo.travaglini@arm.com// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in 497213481Sgiacomo.travaglini@arm.com// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. 497313481Sgiacomo.travaglini@arm.comstd::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, 497413481Sgiacomo.travaglini@arm.com int skip_count) { 497513481Sgiacomo.travaglini@arm.com // We pass skip_count + 1 to skip this wrapper function in addition 497613481Sgiacomo.travaglini@arm.com // to what the user really wants to skip. 497713481Sgiacomo.travaglini@arm.com return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); 497813481Sgiacomo.travaglini@arm.com} 497913481Sgiacomo.travaglini@arm.com 498013481Sgiacomo.travaglini@arm.com// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to 498113481Sgiacomo.travaglini@arm.com// suppress unreachable code warnings. 498213481Sgiacomo.travaglini@arm.comnamespace { 498313481Sgiacomo.travaglini@arm.comclass ClassUniqueToAlwaysTrue {}; 498413481Sgiacomo.travaglini@arm.com} 498513481Sgiacomo.travaglini@arm.com 498613481Sgiacomo.travaglini@arm.combool IsTrue(bool condition) { return condition; } 498713481Sgiacomo.travaglini@arm.com 498813481Sgiacomo.travaglini@arm.combool AlwaysTrue() { 498913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 499013481Sgiacomo.travaglini@arm.com // This condition is always false so AlwaysTrue() never actually throws, 499113481Sgiacomo.travaglini@arm.com // but it makes the compiler think that it may throw. 499213481Sgiacomo.travaglini@arm.com if (IsTrue(false)) 499313481Sgiacomo.travaglini@arm.com throw ClassUniqueToAlwaysTrue(); 499413481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_EXCEPTIONS 499513481Sgiacomo.travaglini@arm.com return true; 499613481Sgiacomo.travaglini@arm.com} 499713481Sgiacomo.travaglini@arm.com 499813481Sgiacomo.travaglini@arm.com// If *pstr starts with the given prefix, modifies *pstr to be right 499913481Sgiacomo.travaglini@arm.com// past the prefix and returns true; otherwise leaves *pstr unchanged 500013481Sgiacomo.travaglini@arm.com// and returns false. None of pstr, *pstr, and prefix can be NULL. 500113481Sgiacomo.travaglini@arm.combool SkipPrefix(const char* prefix, const char** pstr) { 500213481Sgiacomo.travaglini@arm.com const size_t prefix_len = strlen(prefix); 500313481Sgiacomo.travaglini@arm.com if (strncmp(*pstr, prefix, prefix_len) == 0) { 500413481Sgiacomo.travaglini@arm.com *pstr += prefix_len; 500513481Sgiacomo.travaglini@arm.com return true; 500613481Sgiacomo.travaglini@arm.com } 500713481Sgiacomo.travaglini@arm.com return false; 500813481Sgiacomo.travaglini@arm.com} 500913481Sgiacomo.travaglini@arm.com 501013481Sgiacomo.travaglini@arm.com// Parses a string as a command line flag. The string should have 501113481Sgiacomo.travaglini@arm.com// the format "--flag=value". When def_optional is true, the "=value" 501213481Sgiacomo.travaglini@arm.com// part can be omitted. 501313481Sgiacomo.travaglini@arm.com// 501413481Sgiacomo.travaglini@arm.com// Returns the value of the flag, or NULL if the parsing failed. 501513481Sgiacomo.travaglini@arm.comconst char* ParseFlagValue(const char* str, 501613481Sgiacomo.travaglini@arm.com const char* flag, 501713481Sgiacomo.travaglini@arm.com bool def_optional) { 501813481Sgiacomo.travaglini@arm.com // str and flag must not be NULL. 501913481Sgiacomo.travaglini@arm.com if (str == NULL || flag == NULL) return NULL; 502013481Sgiacomo.travaglini@arm.com 502113481Sgiacomo.travaglini@arm.com // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. 502213481Sgiacomo.travaglini@arm.com const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; 502313481Sgiacomo.travaglini@arm.com const size_t flag_len = flag_str.length(); 502413481Sgiacomo.travaglini@arm.com if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; 502513481Sgiacomo.travaglini@arm.com 502613481Sgiacomo.travaglini@arm.com // Skips the flag name. 502713481Sgiacomo.travaglini@arm.com const char* flag_end = str + flag_len; 502813481Sgiacomo.travaglini@arm.com 502913481Sgiacomo.travaglini@arm.com // When def_optional is true, it's OK to not have a "=value" part. 503013481Sgiacomo.travaglini@arm.com if (def_optional && (flag_end[0] == '\0')) { 503113481Sgiacomo.travaglini@arm.com return flag_end; 503213481Sgiacomo.travaglini@arm.com } 503313481Sgiacomo.travaglini@arm.com 503413481Sgiacomo.travaglini@arm.com // If def_optional is true and there are more characters after the 503513481Sgiacomo.travaglini@arm.com // flag name, or if def_optional is false, there must be a '=' after 503613481Sgiacomo.travaglini@arm.com // the flag name. 503713481Sgiacomo.travaglini@arm.com if (flag_end[0] != '=') return NULL; 503813481Sgiacomo.travaglini@arm.com 503913481Sgiacomo.travaglini@arm.com // Returns the string after "=". 504013481Sgiacomo.travaglini@arm.com return flag_end + 1; 504113481Sgiacomo.travaglini@arm.com} 504213481Sgiacomo.travaglini@arm.com 504313481Sgiacomo.travaglini@arm.com// Parses a string for a bool flag, in the form of either 504413481Sgiacomo.travaglini@arm.com// "--flag=value" or "--flag". 504513481Sgiacomo.travaglini@arm.com// 504613481Sgiacomo.travaglini@arm.com// In the former case, the value is taken as true as long as it does 504713481Sgiacomo.travaglini@arm.com// not start with '0', 'f', or 'F'. 504813481Sgiacomo.travaglini@arm.com// 504913481Sgiacomo.travaglini@arm.com// In the latter case, the value is taken as true. 505013481Sgiacomo.travaglini@arm.com// 505113481Sgiacomo.travaglini@arm.com// On success, stores the value of the flag in *value, and returns 505213481Sgiacomo.travaglini@arm.com// true. On failure, returns false without changing *value. 505313481Sgiacomo.travaglini@arm.combool ParseBoolFlag(const char* str, const char* flag, bool* value) { 505413481Sgiacomo.travaglini@arm.com // Gets the value of the flag as a string. 505513481Sgiacomo.travaglini@arm.com const char* const value_str = ParseFlagValue(str, flag, true); 505613481Sgiacomo.travaglini@arm.com 505713481Sgiacomo.travaglini@arm.com // Aborts if the parsing failed. 505813481Sgiacomo.travaglini@arm.com if (value_str == NULL) return false; 505913481Sgiacomo.travaglini@arm.com 506013481Sgiacomo.travaglini@arm.com // Converts the string value to a bool. 506113481Sgiacomo.travaglini@arm.com *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); 506213481Sgiacomo.travaglini@arm.com return true; 506313481Sgiacomo.travaglini@arm.com} 506413481Sgiacomo.travaglini@arm.com 506513481Sgiacomo.travaglini@arm.com// Parses a string for an Int32 flag, in the form of 506613481Sgiacomo.travaglini@arm.com// "--flag=value". 506713481Sgiacomo.travaglini@arm.com// 506813481Sgiacomo.travaglini@arm.com// On success, stores the value of the flag in *value, and returns 506913481Sgiacomo.travaglini@arm.com// true. On failure, returns false without changing *value. 507013481Sgiacomo.travaglini@arm.combool ParseInt32Flag(const char* str, const char* flag, Int32* value) { 507113481Sgiacomo.travaglini@arm.com // Gets the value of the flag as a string. 507213481Sgiacomo.travaglini@arm.com const char* const value_str = ParseFlagValue(str, flag, false); 507313481Sgiacomo.travaglini@arm.com 507413481Sgiacomo.travaglini@arm.com // Aborts if the parsing failed. 507513481Sgiacomo.travaglini@arm.com if (value_str == NULL) return false; 507613481Sgiacomo.travaglini@arm.com 507713481Sgiacomo.travaglini@arm.com // Sets *value to the value of the flag. 507813481Sgiacomo.travaglini@arm.com return ParseInt32(Message() << "The value of flag --" << flag, 507913481Sgiacomo.travaglini@arm.com value_str, value); 508013481Sgiacomo.travaglini@arm.com} 508113481Sgiacomo.travaglini@arm.com 508213481Sgiacomo.travaglini@arm.com// Parses a string for a string flag, in the form of 508313481Sgiacomo.travaglini@arm.com// "--flag=value". 508413481Sgiacomo.travaglini@arm.com// 508513481Sgiacomo.travaglini@arm.com// On success, stores the value of the flag in *value, and returns 508613481Sgiacomo.travaglini@arm.com// true. On failure, returns false without changing *value. 508713481Sgiacomo.travaglini@arm.combool ParseStringFlag(const char* str, const char* flag, std::string* value) { 508813481Sgiacomo.travaglini@arm.com // Gets the value of the flag as a string. 508913481Sgiacomo.travaglini@arm.com const char* const value_str = ParseFlagValue(str, flag, false); 509013481Sgiacomo.travaglini@arm.com 509113481Sgiacomo.travaglini@arm.com // Aborts if the parsing failed. 509213481Sgiacomo.travaglini@arm.com if (value_str == NULL) return false; 509313481Sgiacomo.travaglini@arm.com 509413481Sgiacomo.travaglini@arm.com // Sets *value to the value of the flag. 509513481Sgiacomo.travaglini@arm.com *value = value_str; 509613481Sgiacomo.travaglini@arm.com return true; 509713481Sgiacomo.travaglini@arm.com} 509813481Sgiacomo.travaglini@arm.com 509913481Sgiacomo.travaglini@arm.com// Determines whether a string has a prefix that Google Test uses for its 510013481Sgiacomo.travaglini@arm.com// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. 510113481Sgiacomo.travaglini@arm.com// If Google Test detects that a command line flag has its prefix but is not 510213481Sgiacomo.travaglini@arm.com// recognized, it will print its help message. Flags starting with 510313481Sgiacomo.travaglini@arm.com// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test 510413481Sgiacomo.travaglini@arm.com// internal flags and do not trigger the help message. 510513481Sgiacomo.travaglini@arm.comstatic bool HasGoogleTestFlagPrefix(const char* str) { 510613481Sgiacomo.travaglini@arm.com return (SkipPrefix("--", &str) || 510713481Sgiacomo.travaglini@arm.com SkipPrefix("-", &str) || 510813481Sgiacomo.travaglini@arm.com SkipPrefix("/", &str)) && 510913481Sgiacomo.travaglini@arm.com !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && 511013481Sgiacomo.travaglini@arm.com (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || 511113481Sgiacomo.travaglini@arm.com SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); 511213481Sgiacomo.travaglini@arm.com} 511313481Sgiacomo.travaglini@arm.com 511413481Sgiacomo.travaglini@arm.com// Prints a string containing code-encoded text. The following escape 511513481Sgiacomo.travaglini@arm.com// sequences can be used in the string to control the text color: 511613481Sgiacomo.travaglini@arm.com// 511713481Sgiacomo.travaglini@arm.com// @@ prints a single '@' character. 511813481Sgiacomo.travaglini@arm.com// @R changes the color to red. 511913481Sgiacomo.travaglini@arm.com// @G changes the color to green. 512013481Sgiacomo.travaglini@arm.com// @Y changes the color to yellow. 512113481Sgiacomo.travaglini@arm.com// @D changes to the default terminal text color. 512213481Sgiacomo.travaglini@arm.com// 512313481Sgiacomo.travaglini@arm.com// TODO(wan@google.com): Write tests for this once we add stdout 512413481Sgiacomo.travaglini@arm.com// capturing to Google Test. 512513481Sgiacomo.travaglini@arm.comstatic void PrintColorEncoded(const char* str) { 512613481Sgiacomo.travaglini@arm.com GTestColor color = COLOR_DEFAULT; // The current color. 512713481Sgiacomo.travaglini@arm.com 512813481Sgiacomo.travaglini@arm.com // Conceptually, we split the string into segments divided by escape 512913481Sgiacomo.travaglini@arm.com // sequences. Then we print one segment at a time. At the end of 513013481Sgiacomo.travaglini@arm.com // each iteration, the str pointer advances to the beginning of the 513113481Sgiacomo.travaglini@arm.com // next segment. 513213481Sgiacomo.travaglini@arm.com for (;;) { 513313481Sgiacomo.travaglini@arm.com const char* p = strchr(str, '@'); 513413481Sgiacomo.travaglini@arm.com if (p == NULL) { 513513481Sgiacomo.travaglini@arm.com ColoredPrintf(color, "%s", str); 513613481Sgiacomo.travaglini@arm.com return; 513713481Sgiacomo.travaglini@arm.com } 513813481Sgiacomo.travaglini@arm.com 513913481Sgiacomo.travaglini@arm.com ColoredPrintf(color, "%s", std::string(str, p).c_str()); 514013481Sgiacomo.travaglini@arm.com 514113481Sgiacomo.travaglini@arm.com const char ch = p[1]; 514213481Sgiacomo.travaglini@arm.com str = p + 2; 514313481Sgiacomo.travaglini@arm.com if (ch == '@') { 514413481Sgiacomo.travaglini@arm.com ColoredPrintf(color, "@"); 514513481Sgiacomo.travaglini@arm.com } else if (ch == 'D') { 514613481Sgiacomo.travaglini@arm.com color = COLOR_DEFAULT; 514713481Sgiacomo.travaglini@arm.com } else if (ch == 'R') { 514813481Sgiacomo.travaglini@arm.com color = COLOR_RED; 514913481Sgiacomo.travaglini@arm.com } else if (ch == 'G') { 515013481Sgiacomo.travaglini@arm.com color = COLOR_GREEN; 515113481Sgiacomo.travaglini@arm.com } else if (ch == 'Y') { 515213481Sgiacomo.travaglini@arm.com color = COLOR_YELLOW; 515313481Sgiacomo.travaglini@arm.com } else { 515413481Sgiacomo.travaglini@arm.com --str; 515513481Sgiacomo.travaglini@arm.com } 515613481Sgiacomo.travaglini@arm.com } 515713481Sgiacomo.travaglini@arm.com} 515813481Sgiacomo.travaglini@arm.com 515913481Sgiacomo.travaglini@arm.comstatic const char kColorEncodedHelpMessage[] = 516013481Sgiacomo.travaglini@arm.com"This program contains tests written using " GTEST_NAME_ ". You can use the\n" 516113481Sgiacomo.travaglini@arm.com"following command line flags to control its behavior:\n" 516213481Sgiacomo.travaglini@arm.com"\n" 516313481Sgiacomo.travaglini@arm.com"Test Selection:\n" 516413481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" 516513481Sgiacomo.travaglini@arm.com" List the names of all tests instead of running them. The name of\n" 516613481Sgiacomo.travaglini@arm.com" TEST(Foo, Bar) is \"Foo.Bar\".\n" 516713481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" 516813481Sgiacomo.travaglini@arm.com "[@G-@YNEGATIVE_PATTERNS]@D\n" 516913481Sgiacomo.travaglini@arm.com" Run only the tests whose name matches one of the positive patterns but\n" 517013481Sgiacomo.travaglini@arm.com" none of the negative patterns. '?' matches any single character; '*'\n" 517113481Sgiacomo.travaglini@arm.com" matches any substring; ':' separates two patterns.\n" 517213481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" 517313481Sgiacomo.travaglini@arm.com" Run all disabled tests too.\n" 517413481Sgiacomo.travaglini@arm.com"\n" 517513481Sgiacomo.travaglini@arm.com"Test Execution:\n" 517613481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" 517713481Sgiacomo.travaglini@arm.com" Run the tests repeatedly; use a negative count to repeat forever.\n" 517813481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" 517913481Sgiacomo.travaglini@arm.com" Randomize tests' orders on every iteration.\n" 518013481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" 518113481Sgiacomo.travaglini@arm.com" Random number seed to use for shuffling test orders (between 1 and\n" 518213481Sgiacomo.travaglini@arm.com" 99999, or 0 to use a seed based on the current time).\n" 518313481Sgiacomo.travaglini@arm.com"\n" 518413481Sgiacomo.travaglini@arm.com"Test Output:\n" 518513481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" 518613481Sgiacomo.travaglini@arm.com" Enable/disable colored output. The default is @Gauto@D.\n" 518713481Sgiacomo.travaglini@arm.com" -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" 518813481Sgiacomo.travaglini@arm.com" Don't print the elapsed time of each test.\n" 518913481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" 519013481Sgiacomo.travaglini@arm.com GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" 519113481Sgiacomo.travaglini@arm.com" Generate an XML report in the given directory or with the given file\n" 519213481Sgiacomo.travaglini@arm.com" name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" 519313481Sgiacomo.travaglini@arm.com#if GTEST_CAN_STREAM_RESULTS_ 519413481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" 519513481Sgiacomo.travaglini@arm.com" Stream test results to the given server.\n" 519613481Sgiacomo.travaglini@arm.com#endif // GTEST_CAN_STREAM_RESULTS_ 519713481Sgiacomo.travaglini@arm.com"\n" 519813481Sgiacomo.travaglini@arm.com"Assertion Behavior:\n" 519913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 520013481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" 520113481Sgiacomo.travaglini@arm.com" Set the default death test style.\n" 520213481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 520313481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" 520413481Sgiacomo.travaglini@arm.com" Turn assertion failures into debugger break-points.\n" 520513481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" 520613481Sgiacomo.travaglini@arm.com" Turn assertion failures into C++ exceptions.\n" 520713481Sgiacomo.travaglini@arm.com" @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" 520813481Sgiacomo.travaglini@arm.com" Do not report exceptions as test failures. Instead, allow them\n" 520913481Sgiacomo.travaglini@arm.com" to crash the program or throw a pop-up (on Windows).\n" 521013481Sgiacomo.travaglini@arm.com"\n" 521113481Sgiacomo.travaglini@arm.com"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " 521213481Sgiacomo.travaglini@arm.com "the corresponding\n" 521313481Sgiacomo.travaglini@arm.com"environment variable of a flag (all letters in upper-case). For example, to\n" 521413481Sgiacomo.travaglini@arm.com"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ 521513481Sgiacomo.travaglini@arm.com "color=no@D or set\n" 521613481Sgiacomo.travaglini@arm.com"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" 521713481Sgiacomo.travaglini@arm.com"\n" 521813481Sgiacomo.travaglini@arm.com"For more information, please read the " GTEST_NAME_ " documentation at\n" 521913481Sgiacomo.travaglini@arm.com"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" 522013481Sgiacomo.travaglini@arm.com"(not one in your own code or tests), please report it to\n" 522113481Sgiacomo.travaglini@arm.com"@G<" GTEST_DEV_EMAIL_ ">@D.\n"; 522213481Sgiacomo.travaglini@arm.com 522313481Sgiacomo.travaglini@arm.combool ParseGoogleTestFlag(const char* const arg) { 522413481Sgiacomo.travaglini@arm.com return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, 522513481Sgiacomo.travaglini@arm.com >EST_FLAG(also_run_disabled_tests)) || 522613481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kBreakOnFailureFlag, 522713481Sgiacomo.travaglini@arm.com >EST_FLAG(break_on_failure)) || 522813481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kCatchExceptionsFlag, 522913481Sgiacomo.travaglini@arm.com >EST_FLAG(catch_exceptions)) || 523013481Sgiacomo.travaglini@arm.com ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || 523113481Sgiacomo.travaglini@arm.com ParseStringFlag(arg, kDeathTestStyleFlag, 523213481Sgiacomo.travaglini@arm.com >EST_FLAG(death_test_style)) || 523313481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kDeathTestUseFork, 523413481Sgiacomo.travaglini@arm.com >EST_FLAG(death_test_use_fork)) || 523513481Sgiacomo.travaglini@arm.com ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || 523613481Sgiacomo.travaglini@arm.com ParseStringFlag(arg, kInternalRunDeathTestFlag, 523713481Sgiacomo.travaglini@arm.com >EST_FLAG(internal_run_death_test)) || 523813481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || 523913481Sgiacomo.travaglini@arm.com ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || 524013481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || 524113481Sgiacomo.travaglini@arm.com ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || 524213481Sgiacomo.travaglini@arm.com ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || 524313481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || 524413481Sgiacomo.travaglini@arm.com ParseInt32Flag(arg, kStackTraceDepthFlag, 524513481Sgiacomo.travaglini@arm.com >EST_FLAG(stack_trace_depth)) || 524613481Sgiacomo.travaglini@arm.com ParseStringFlag(arg, kStreamResultToFlag, 524713481Sgiacomo.travaglini@arm.com >EST_FLAG(stream_result_to)) || 524813481Sgiacomo.travaglini@arm.com ParseBoolFlag(arg, kThrowOnFailureFlag, 524913481Sgiacomo.travaglini@arm.com >EST_FLAG(throw_on_failure)); 525013481Sgiacomo.travaglini@arm.com} 525113481Sgiacomo.travaglini@arm.com 525213481Sgiacomo.travaglini@arm.com#if GTEST_USE_OWN_FLAGFILE_FLAG_ 525313481Sgiacomo.travaglini@arm.comvoid LoadFlagsFromFile(const std::string& path) { 525413481Sgiacomo.travaglini@arm.com FILE* flagfile = posix::FOpen(path.c_str(), "r"); 525513481Sgiacomo.travaglini@arm.com if (!flagfile) { 525613481Sgiacomo.travaglini@arm.com fprintf(stderr, 525713481Sgiacomo.travaglini@arm.com "Unable to open file \"%s\"\n", 525813481Sgiacomo.travaglini@arm.com GTEST_FLAG(flagfile).c_str()); 525913481Sgiacomo.travaglini@arm.com fflush(stderr); 526013481Sgiacomo.travaglini@arm.com exit(EXIT_FAILURE); 526113481Sgiacomo.travaglini@arm.com } 526213481Sgiacomo.travaglini@arm.com std::string contents(ReadEntireFile(flagfile)); 526313481Sgiacomo.travaglini@arm.com posix::FClose(flagfile); 526413481Sgiacomo.travaglini@arm.com std::vector<std::string> lines; 526513481Sgiacomo.travaglini@arm.com SplitString(contents, '\n', &lines); 526613481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < lines.size(); ++i) { 526713481Sgiacomo.travaglini@arm.com if (lines[i].empty()) 526813481Sgiacomo.travaglini@arm.com continue; 526913481Sgiacomo.travaglini@arm.com if (!ParseGoogleTestFlag(lines[i].c_str())) 527013481Sgiacomo.travaglini@arm.com g_help_flag = true; 527113481Sgiacomo.travaglini@arm.com } 527213481Sgiacomo.travaglini@arm.com} 527313481Sgiacomo.travaglini@arm.com#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ 527413481Sgiacomo.travaglini@arm.com 527513481Sgiacomo.travaglini@arm.com// Parses the command line for Google Test flags, without initializing 527613481Sgiacomo.travaglini@arm.com// other parts of Google Test. The type parameter CharType can be 527713481Sgiacomo.travaglini@arm.com// instantiated to either char or wchar_t. 527813481Sgiacomo.travaglini@arm.comtemplate <typename CharType> 527913481Sgiacomo.travaglini@arm.comvoid ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { 528013481Sgiacomo.travaglini@arm.com for (int i = 1; i < *argc; i++) { 528113481Sgiacomo.travaglini@arm.com const std::string arg_string = StreamableToString(argv[i]); 528213481Sgiacomo.travaglini@arm.com const char* const arg = arg_string.c_str(); 528313481Sgiacomo.travaglini@arm.com 528413481Sgiacomo.travaglini@arm.com using internal::ParseBoolFlag; 528513481Sgiacomo.travaglini@arm.com using internal::ParseInt32Flag; 528613481Sgiacomo.travaglini@arm.com using internal::ParseStringFlag; 528713481Sgiacomo.travaglini@arm.com 528813481Sgiacomo.travaglini@arm.com bool remove_flag = false; 528913481Sgiacomo.travaglini@arm.com if (ParseGoogleTestFlag(arg)) { 529013481Sgiacomo.travaglini@arm.com remove_flag = true; 529113481Sgiacomo.travaglini@arm.com#if GTEST_USE_OWN_FLAGFILE_FLAG_ 529213481Sgiacomo.travaglini@arm.com } else if (ParseStringFlag(arg, kFlagfileFlag, >EST_FLAG(flagfile))) { 529313481Sgiacomo.travaglini@arm.com LoadFlagsFromFile(GTEST_FLAG(flagfile)); 529413481Sgiacomo.travaglini@arm.com remove_flag = true; 529513481Sgiacomo.travaglini@arm.com#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ 529613481Sgiacomo.travaglini@arm.com } else if (arg_string == "--help" || arg_string == "-h" || 529713481Sgiacomo.travaglini@arm.com arg_string == "-?" || arg_string == "/?" || 529813481Sgiacomo.travaglini@arm.com HasGoogleTestFlagPrefix(arg)) { 529913481Sgiacomo.travaglini@arm.com // Both help flag and unrecognized Google Test flags (excluding 530013481Sgiacomo.travaglini@arm.com // internal ones) trigger help display. 530113481Sgiacomo.travaglini@arm.com g_help_flag = true; 530213481Sgiacomo.travaglini@arm.com } 530313481Sgiacomo.travaglini@arm.com 530413481Sgiacomo.travaglini@arm.com if (remove_flag) { 530513481Sgiacomo.travaglini@arm.com // Shift the remainder of the argv list left by one. Note 530613481Sgiacomo.travaglini@arm.com // that argv has (*argc + 1) elements, the last one always being 530713481Sgiacomo.travaglini@arm.com // NULL. The following loop moves the trailing NULL element as 530813481Sgiacomo.travaglini@arm.com // well. 530913481Sgiacomo.travaglini@arm.com for (int j = i; j != *argc; j++) { 531013481Sgiacomo.travaglini@arm.com argv[j] = argv[j + 1]; 531113481Sgiacomo.travaglini@arm.com } 531213481Sgiacomo.travaglini@arm.com 531313481Sgiacomo.travaglini@arm.com // Decrements the argument count. 531413481Sgiacomo.travaglini@arm.com (*argc)--; 531513481Sgiacomo.travaglini@arm.com 531613481Sgiacomo.travaglini@arm.com // We also need to decrement the iterator as we just removed 531713481Sgiacomo.travaglini@arm.com // an element. 531813481Sgiacomo.travaglini@arm.com i--; 531913481Sgiacomo.travaglini@arm.com } 532013481Sgiacomo.travaglini@arm.com } 532113481Sgiacomo.travaglini@arm.com 532213481Sgiacomo.travaglini@arm.com if (g_help_flag) { 532313481Sgiacomo.travaglini@arm.com // We print the help here instead of in RUN_ALL_TESTS(), as the 532413481Sgiacomo.travaglini@arm.com // latter may not be called at all if the user is using Google 532513481Sgiacomo.travaglini@arm.com // Test with another testing framework. 532613481Sgiacomo.travaglini@arm.com PrintColorEncoded(kColorEncodedHelpMessage); 532713481Sgiacomo.travaglini@arm.com } 532813481Sgiacomo.travaglini@arm.com} 532913481Sgiacomo.travaglini@arm.com 533013481Sgiacomo.travaglini@arm.com// Parses the command line for Google Test flags, without initializing 533113481Sgiacomo.travaglini@arm.com// other parts of Google Test. 533213481Sgiacomo.travaglini@arm.comvoid ParseGoogleTestFlagsOnly(int* argc, char** argv) { 533313481Sgiacomo.travaglini@arm.com ParseGoogleTestFlagsOnlyImpl(argc, argv); 533413481Sgiacomo.travaglini@arm.com} 533513481Sgiacomo.travaglini@arm.comvoid ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { 533613481Sgiacomo.travaglini@arm.com ParseGoogleTestFlagsOnlyImpl(argc, argv); 533713481Sgiacomo.travaglini@arm.com} 533813481Sgiacomo.travaglini@arm.com 533913481Sgiacomo.travaglini@arm.com// The internal implementation of InitGoogleTest(). 534013481Sgiacomo.travaglini@arm.com// 534113481Sgiacomo.travaglini@arm.com// The type parameter CharType can be instantiated to either char or 534213481Sgiacomo.travaglini@arm.com// wchar_t. 534313481Sgiacomo.travaglini@arm.comtemplate <typename CharType> 534413481Sgiacomo.travaglini@arm.comvoid InitGoogleTestImpl(int* argc, CharType** argv) { 534513481Sgiacomo.travaglini@arm.com // We don't want to run the initialization code twice. 534613481Sgiacomo.travaglini@arm.com if (GTestIsInitialized()) return; 534713481Sgiacomo.travaglini@arm.com 534813481Sgiacomo.travaglini@arm.com if (*argc <= 0) return; 534913481Sgiacomo.travaglini@arm.com 535013481Sgiacomo.travaglini@arm.com g_argvs.clear(); 535113481Sgiacomo.travaglini@arm.com for (int i = 0; i != *argc; i++) { 535213481Sgiacomo.travaglini@arm.com g_argvs.push_back(StreamableToString(argv[i])); 535313481Sgiacomo.travaglini@arm.com } 535413481Sgiacomo.travaglini@arm.com 535513481Sgiacomo.travaglini@arm.com ParseGoogleTestFlagsOnly(argc, argv); 535613481Sgiacomo.travaglini@arm.com GetUnitTestImpl()->PostFlagParsingInit(); 535713481Sgiacomo.travaglini@arm.com} 535813481Sgiacomo.travaglini@arm.com 535913481Sgiacomo.travaglini@arm.com} // namespace internal 536013481Sgiacomo.travaglini@arm.com 536113481Sgiacomo.travaglini@arm.com// Initializes Google Test. This must be called before calling 536213481Sgiacomo.travaglini@arm.com// RUN_ALL_TESTS(). In particular, it parses a command line for the 536313481Sgiacomo.travaglini@arm.com// flags that Google Test recognizes. Whenever a Google Test flag is 536413481Sgiacomo.travaglini@arm.com// seen, it is removed from argv, and *argc is decremented. 536513481Sgiacomo.travaglini@arm.com// 536613481Sgiacomo.travaglini@arm.com// No value is returned. Instead, the Google Test flag variables are 536713481Sgiacomo.travaglini@arm.com// updated. 536813481Sgiacomo.travaglini@arm.com// 536913481Sgiacomo.travaglini@arm.com// Calling the function for the second time has no user-visible effect. 537013481Sgiacomo.travaglini@arm.comvoid InitGoogleTest(int* argc, char** argv) { 537113481Sgiacomo.travaglini@arm.com#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 537213481Sgiacomo.travaglini@arm.com GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv); 537313481Sgiacomo.travaglini@arm.com#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 537413481Sgiacomo.travaglini@arm.com internal::InitGoogleTestImpl(argc, argv); 537513481Sgiacomo.travaglini@arm.com#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 537613481Sgiacomo.travaglini@arm.com} 537713481Sgiacomo.travaglini@arm.com 537813481Sgiacomo.travaglini@arm.com// This overloaded version can be used in Windows programs compiled in 537913481Sgiacomo.travaglini@arm.com// UNICODE mode. 538013481Sgiacomo.travaglini@arm.comvoid InitGoogleTest(int* argc, wchar_t** argv) { 538113481Sgiacomo.travaglini@arm.com#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 538213481Sgiacomo.travaglini@arm.com GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv); 538313481Sgiacomo.travaglini@arm.com#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 538413481Sgiacomo.travaglini@arm.com internal::InitGoogleTestImpl(argc, argv); 538513481Sgiacomo.travaglini@arm.com#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 538613481Sgiacomo.travaglini@arm.com} 538713481Sgiacomo.travaglini@arm.com 538813481Sgiacomo.travaglini@arm.com} // namespace testing 5389