1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2005, Google Inc. 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// All rights reserved. 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Author: wan@google.com (Zhanyong Wan) 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The Google C++ Testing Framework (Google Test) 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This header file defines the public API for Google Test. It should be 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// included by any test program that uses Google Test. 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// IMPORTANT NOTE: Due to limitation of the C++ language, we have to 38fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// leave some internal implementation details in this header file. 39fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// They are clearly marked by comments like this: 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Such code is NOT meant to be used by a user directly, and is subject 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user 45fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// program! 46fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Acknowledgment: Google Test borrowed the idea of automatic test 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// registration from Barthelemy Dagenais' (barthelemy@prologique.com) 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// easyUnit framework. 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_INCLUDE_GTEST_GTEST_H_ 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <limits> 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/internal/gtest-internal.h> 56fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/internal/gtest-string.h> 57fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-death-test.h> 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-message.h> 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-param-test.h> 60fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest_prod.h> 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-test-part.h> 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-typed-test.h> 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Depending on the platform, different string classes are available. 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// On Windows, ::std::string compiles only when exceptions are 66fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// enabled. On Linux, in addition to ::std::string, Google also makes 67fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// use of class ::string, which has the same interface as 68fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ::std::string, but has a different implementation. 69fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 70fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user can tell us whether ::std::string is available in his 71fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// environment by defining the macro GTEST_HAS_STD_STRING to either 1 72fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// or 0 on the compiler command line. He can also define 73fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_GLOBAL_STRING to 1 to indicate that ::string is available 74fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// AND is a distinct type to ::std::string, or define it to 0 to 75fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// indicate otherwise. 76fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 77fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the user's ::std::string and ::string are the same class due to 78fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// aliasing, he should define GTEST_HAS_STD_STRING to 1 and 79fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_GLOBAL_STRING to 0. 80fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 81fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the user doesn't define GTEST_HAS_STD_STRING and/or 82fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_GLOBAL_STRING, they are defined heuristically. 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace testing { 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Declares the flags. 87fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 88fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag temporary enables the disabled tests. 89fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(also_run_disabled_tests); 90fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag brings the debugger on an assertion failure. 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(break_on_failure); 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag controls whether Google Test catches all test-thrown exceptions 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and logs them as failures. 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(catch_exceptions); 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag enables using colors in terminal output. Available values are 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "yes" to enable colors, "no" (disable colors), or "auto" (the default) 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to let Google Test decide. 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_string_(color); 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag sets up the filter to select by name using a glob pattern 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the tests to run. If the filter is not given all tests are executed. 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_string_(filter); 106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag causes the Google Test to list tests. None of the tests listed 108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// are actually run if the flag is provided. 109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(list_tests); 110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag controls whether Google Test emits a detailed XML report to a file 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in addition to its normal textual output. 113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_string_(output); 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flags control whether Google Test prints the elapsed time for each 116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// test. 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(print_time); 118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag specifies the random number seed. 120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_int32_(random_seed); 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag sets how many times the tests are repeated. The default value 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is 1. If the value is -1 the tests are repeating forever. 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_int32_(repeat); 125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag controls whether Google Test includes Google Test internal 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// stack frames in failure stack traces. 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(show_internal_stack_frames); 129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 130d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// When this flag is specified, tests' order is randomized on every iteration. 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(shuffle); 132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This flag specifies the maximum number of stack frames to be 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// printed in a failure message. 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_int32_(stack_trace_depth); 136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When this flag is specified, a failed assertion will throw an 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// exception if exceptions are enabled, or exit the program with a 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// non-zero code otherwise. 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(throw_on_failure); 141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The upper limit for valid stack trace depths. 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst int kMaxStackTraceDepth = 100; 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass AssertHelper; 148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass DefaultGlobalTestPartResultReporter; 149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass ExecDeathTest; 150d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass NoExecDeathTest; 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass FinalSuccessChecker; 152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass GTestFlagSaver; 153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestInfoImpl; 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestResultAccessor; 155d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass TestEventListenersAccessor; 156d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass TestEventRepeater; 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass WindowsDeathTest; 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass UnitTestImpl* GetUnitTestImpl(); 159d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savillevoid ReportFailureInUnknownLocation(TestPartResult::Type result_type, 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const String& message); 161d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass PrettyUnitTestResultPrinter; 162d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass XmlUnitTestResultPrinter; 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Converts a streamable value to a String. A NULL pointer is 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// converted to "(null)". When the input value is a ::string, 166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ::std::string, ::wstring, or ::std::wstring object, each NUL 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// character in it is replaced with "\\0". 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Declared in gtest-internal.h but defined here, so that it has access 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to the definition of the Message class, required by the ARM 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// compiler. 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleString StreamableToString(const T& streamable) { 173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (Message() << streamable).GetString(); 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A class for indicating whether an assertion was successful. When 179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the assertion wasn't successful, the AssertionResult object 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// remembers a non-empty message that described how it failed. 181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This class is useful for defining predicate-format functions to be 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The constructor of AssertionResult is private. To create an 186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instance of this class, use one of the factory functions 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (AssertionSuccess() and AssertionFailure()). 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For example, in order to be able to write: 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Verifies that Foo() returns an even number. 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_PRED_FORMAT1(IsEven, Foo()); 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// you just need to define: 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// testing::AssertionResult IsEven(const char* expr, int n) { 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// if ((n % 2) == 0) return testing::AssertionSuccess(); 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Message msg; 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// msg << "Expected: " << expr << " is even\n" 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// << " Actual: it's " << n; 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// return testing::AssertionFailure(msg); 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If Foo() returns 5, you will see the following message: 206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Expected: Foo() is even 208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Actual: it's 5 209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass AssertionResult { 210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Declares factory functions for making successful and failed 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // assertion results as friends. 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend AssertionResult AssertionSuccess(); 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend AssertionResult AssertionFailure(const Message&); 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the assertion succeeded. 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville operator bool() const { return failure_message_.c_str() == NULL; } // NOLINT 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the assertion's failure message. 220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* failure_message() const { return failure_message_.c_str(); } 221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The default constructor. It is used when the assertion succeeded. 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville AssertionResult() {} 225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The constructor used when the assertion failed. 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit AssertionResult(const internal::String& failure_message); 228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Stores the assertion's failure message. 230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::String failure_message_; 231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Makes a successful assertion result. 234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult AssertionSuccess(); 235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Makes a failed assertion result with the given failure message. 237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult AssertionFailure(const Message& msg); 238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The abstract class that all tests inherit from. 240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In Google Test, a unit test program contains one or many TestCases, and 242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// each TestCase contains one or many Tests. 243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When you define a test using the TEST macro, you don't need to 245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// explicitly derive from Test - the TEST macro automatically does 246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this for you. 247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The only time you derive from Test is when defining a test fixture 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to be used a TEST_F. For example: 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// class FooTest : public testing::Test { 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// protected: 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// virtual void SetUp() { ... } 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// virtual void TearDown() { ... } 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ... 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// }; 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TEST_F(FooTest, Bar) { ... } 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TEST_F(FooTest, Baz) { ... } 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test is not copyable. 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass Test { 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::TestInfoImpl; 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Defines types for pointers to functions that set up and tear down 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // a test case. 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc; 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc; 270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The d'tor is virtual as we intend to inherit from Test. 272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~Test(); 273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets up the stuff shared by all tests in this test case. 275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Google Test will call Foo::SetUpTestCase() before running the first 277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test in test case Foo. Hence a sub-class can define its own 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // SetUpTestCase() method to shadow the one defined in the super 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // class. 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void SetUpTestCase() {} 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tears down the stuff shared by all tests in this test case. 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Google Test will call Foo::TearDownTestCase() after running the last 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test in test case Foo. Hence a sub-class can define its own 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TearDownTestCase() method to shadow the one defined in the super 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // class. 288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void TearDownTestCase() {} 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the current test has a fatal failure. 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool HasFatalFailure(); 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the current test has a non-fatal failure. 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool HasNonfatalFailure(); 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the current test has a (either fatal or 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // non-fatal) failure. 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Logs a property for the current test. Only the last value for a given 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // key is remembered. 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // These are public static so they can be called from utility functions 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // that are not members of the test fixture. 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The arguments are const char* instead strings, as Google Test is used 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // on platforms where string doesn't compile. 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Note that a driving consideration for these RecordProperty methods 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // was to produce xml output suited to the Greenspan charting utility, 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // which at present will only chart values that fit in a 32-bit int. It 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // is the user's responsibility to restrict their values to 32-bit ints 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // if they intend them to be used with Greenspan. 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void RecordProperty(const char* key, const char* value); 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void RecordProperty(const char* key, int value); 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville protected: 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Creates a Test object. 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test(); 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets up the test fixture. 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void SetUp(); 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tears down the test fixture. 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void TearDown(); 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the current test has the same fixture class as 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the first test in the current test case. 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool HasSameFixtureClass(); 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Runs the test after the test fixture has been set up. 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // A sub-class must implement this to define the test logic. 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Instead, use the TEST or TEST_F macro. 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void TestBody() = 0; 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets up, executes, and tears down the test. 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run(); 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Uses a GTestFlagSaver to save and restore all Google Test flags. 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::GTestFlagSaver* const gtest_flag_saver_; 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Often a user mis-spells SetUp() as Setup() and spends a long time 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // wondering why it is never called by Google Test. The declaration of 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the following method is solely for catching such an error at 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // compile time: 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // - The return type is deliberately chosen to be not void, so it 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // will be a conflict if a user declares void Setup() in his test 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // fixture. 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // - This method is private, so it will be another compiler error 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // if a user calls it from his test fixture. 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // DO NOT OVERRIDE THIS FUNCTION. 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If you see an error about overriding the following function or 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // about it being private, you have mis-spelled SetUp() as Setup(). 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville struct Setup_should_be_spelled_SetUp {}; 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We disallow copying Tests. 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef internal::TimeInMillis TimeInMillis; 368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A copyable object representing a user specified test property which can be 370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// output as a key/value string pair. 371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Don't inherit from TestProperty as its destructor is not virtual. 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestProperty { 374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // C'tor. TestProperty does NOT have a default constructor. 376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Always use this constructor (with parameters) to create a 377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TestProperty object. 378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestProperty(const char* key, const char* value) : 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville key_(key), value_(value) { 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the user supplied key. 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* key() const { 384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return key_.c_str(); 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the user supplied value. 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* value() const { 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return value_.c_str(); 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets a new value, overriding the one supplied in the constructor. 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void SetValue(const char* new_value) { 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville value_ = new_value; 395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The key supplied by the user. 399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::String key_; 400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The value supplied by the user. 401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::String value_; 402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The result of a single Test. This includes a list of 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TestPartResults, a list of TestProperties, a count of how many 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// death tests there are in the Test, and how much time it took to run 407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the Test. 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TestResult is not copyable. 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestResult { 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Creates an empty TestResult. 413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestResult(); 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // D'tor. Do not inherit from TestResult. 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~TestResult(); 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all test parts. This is the sum of the number 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // of successful test parts and the number of failed test parts. 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int total_part_count() const; 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the number of the test properties. 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_property_count() const; 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test passed (i.e. no test part failed). 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Passed() const { return !Failed(); } 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test failed. 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Failed() const; 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test fatally failed. 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool HasFatalFailure() const; 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test has a non-fatal failure. 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool HasNonfatalFailure() const; 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the elapsed time, in milliseconds. 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time() const { return elapsed_time_; } 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the i-th test part result among all the results. i can range 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // from 0 to test_property_count() - 1. If i is not in that range, aborts 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the program. 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestPartResult& GetTestPartResult(int i) const; 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the i-th test property. i can range from 0 to 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test_property_count() - 1. If i is not in that range, aborts the 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // program. 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestProperty& GetTestProperty(int i) const; 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 451d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class TestInfo; 452d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class UnitTest; 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::DefaultGlobalTestPartResultReporter; 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::ExecDeathTest; 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::TestInfoImpl; 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::TestResultAccessor; 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::UnitTestImpl; 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::WindowsDeathTest; 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the vector of TestPartResults. 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::Vector<TestPartResult>& test_part_results() const { 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *test_part_results_; 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the vector of TestProperties. 466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::Vector<TestProperty>& test_properties() const { 467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *test_properties_; 468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the elapsed time. 471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } 472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds a test property to the list. The property is validated and may add 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // a non-fatal failure if invalid (e.g., if it conflicts with reserved 475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // key names). If a property is already recorded for the same key, the 476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // value will be updated, rather than storing multiple values for the same 477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // key. 478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void RecordProperty(const TestProperty& test_property); 479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds a failure if the key is a reserved attribute of Google Test 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // testcase tags. Returns true if the property is valid. 482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TODO(russr): Validate attribute names are legal and human readable. 483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool ValidateTestProperty(const TestProperty& test_property); 484fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds a test part result to the list. 486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void AddTestPartResult(const TestPartResult& test_part_result); 487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the death test count. 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int death_test_count() const { return death_test_count_; } 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Increments the death test count, returning the new count. 492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int increment_death_test_count() { return ++death_test_count_; } 493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the test part results. 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void ClearTestPartResults(); 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the object. 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Clear(); 499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Protects mutable state of the property vector and of owned 501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // properties, whose values may be updated. 502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Mutex test_properites_mutex_; 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The vector of TestPartResults 505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::scoped_ptr<internal::Vector<TestPartResult> > test_part_results_; 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The vector of TestProperties 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::scoped_ptr<internal::Vector<TestProperty> > test_properties_; 508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Running count of death tests. 509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int death_test_count_; 510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The elapsed time, in milliseconds. 511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time_; 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We disallow copying TestResult. 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; // class TestResult 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A TestInfo object stores the following information about a test: 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test case name 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test name 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Whether the test should be run 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A function pointer that creates the test object when invoked 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test result 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The constructor of TestInfo registers itself with the UnitTest 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// singleton such that the RUN_ALL_TESTS() macro knows which tests to 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// run. 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestInfo { 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Destructs a TestInfo object. This function is not virtual, so 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // don't inherit from TestInfo. 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~TestInfo(); 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test case name. 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_name() const; 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test name. 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* name() const; 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test case comment. 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_comment() const; 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test comment. 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* comment() const; 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if this test should run, that is if the test is not disabled 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // (or it is disabled but the also_run_disabled_tests flag has been specified) 548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // and its full name matches the user-specified filter. 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Google Test allows the user to filter the tests by their full names. 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The full name of a test Bar in test case Foo is defined as 552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // "Foo.Bar". Only the tests that match the filter will run. 553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // A filter is a colon-separated list of glob (not regex) patterns, 555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // optionally followed by a '-' and a colon-separated list of 556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // negative patterns (tests to exclude). A test is run if it 557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // matches one of the positive patterns and does not match any of 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the negative patterns. 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // For example, *A*:Foo.* is a filter that matches any string that 561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // contains the character 'A' or starts with "Foo.". 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_run() const; 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the result of the test. 565d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const TestResult* result() const; 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_DEATH_TEST 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::DefaultDeathTestFactory; 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_DEATH_TEST 571d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class Test; 572d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class TestCase; 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::TestInfoImpl; 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::UnitTestImpl; 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend TestInfo* internal::MakeAndRegisterTestInfo( 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_name, const char* name, 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_comment, const char* comment, 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TypeId fixture_class_id, 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::SetUpTestCaseFunc set_up_tc, 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::TearDownTestCaseFunc tear_down_tc, 581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TestFactoryBase* factory); 582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if this test matches the user-specified filter. 584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool matches_filter() const; 585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Increments the number of death tests encountered in this test so 587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // far. 588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int increment_death_test_count(); 589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Accessors for the implementation object. 591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TestInfoImpl* impl() { return impl_; } 592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::TestInfoImpl* impl() const { return impl_; } 593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Constructs a TestInfo object. The newly constructed instance assumes 595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // ownership of the factory object. 596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestInfo(const char* test_case_name, const char* name, 597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_comment, const char* comment, 598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TypeId fixture_class_id, 599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TestFactoryBase* factory); 600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // An opaque implementation object. 602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TestInfoImpl* impl_; 603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A test case, which consists of a vector of TestInfos. 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TestCase is not copyable. 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestCase { 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Creates a TestCase with the given name. 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TestCase does NOT have a default constructor. Always use this 615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // constructor to create a TestCase object. 616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Arguments: 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // name: name of the test case 620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // set_up_tc: pointer to the function that sets up the test case 621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // tear_down_tc: pointer to the function that tears down the test case 622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCase(const char* name, const char* comment, 623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::SetUpTestCaseFunc set_up_tc, 624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::TearDownTestCaseFunc tear_down_tc); 625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Destructor of TestCase. 627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~TestCase(); 628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the name of the TestCase. 630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* name() const { return name_.c_str(); } 631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test case comment. 633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* comment() const { return comment_.c_str(); } 634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if any test in this test case should run. 636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_run() const { return should_run_; } 637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of successful tests in this test case. 639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int successful_test_count() const; 640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of failed tests in this test case. 642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int failed_test_count() const; 643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of disabled tests in this test case. 645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int disabled_test_count() const; 646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Get the number of tests in this test case that should run. 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_to_run_count() const; 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all tests in this test case. 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int total_test_count() const; 652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test case passed. 654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Passed() const { return !Failed(); } 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test case failed. 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Failed() const { return failed_test_count() > 0; } 658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the elapsed time, in milliseconds. 660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time() const { return elapsed_time_; } 661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the i-th test among all the tests. i can range from 0 to 663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // total_test_count() - 1. If i is not in that range, returns NULL. 664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestInfo* GetTestInfo(int i) const; 665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 667d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class Test; 668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::UnitTestImpl; 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the (mutable) vector of TestInfos in this TestCase. 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<TestInfo*>& test_info_list() { return *test_info_list_; } 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the (immutable) vector of TestInfos in this TestCase. 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::Vector<TestInfo *> & test_info_list() const { 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *test_info_list_; 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 678d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Returns the i-th test among all the tests. i can range from 0 to 679d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // total_test_count() - 1. If i is not in that range, returns NULL. 680d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestInfo* GetMutableTestInfo(int i); 681d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the should_run member. 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_should_run(bool should) { should_run_ = should; } 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds a TestInfo to this test case. Will delete the TestInfo upon 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // destruction of the TestCase object. 687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void AddTestInfo(TestInfo * test_info); 688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the results of all tests in this test case. 690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void ClearResult(); 691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the results of all tests in the given test case. 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void ClearTestCaseResult(TestCase* test_case) { 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_case->ClearResult(); 695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Runs every test in this TestCase. 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run(); 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff test passed. 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool TestPassed(const TestInfo * test_info); 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff test failed. 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool TestFailed(const TestInfo * test_info); 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff test is disabled. 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool TestDisabled(const TestInfo * test_info); 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if the given test should run. 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool ShouldRunTest(const TestInfo *test_info); 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 712d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Shuffles the tests in this test case. 713d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void ShuffleTests(internal::Random* random); 714d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 715d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Restores the test order to before the first shuffle. 716d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void UnshuffleTests(); 717d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Name of the test case. 719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::String name_; 720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Comment on the test case. 721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::String comment_; 722d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // The vector of TestInfos in their original order. It owns the 723d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // elements in the vector. 724d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const internal::scoped_ptr<internal::Vector<TestInfo*> > test_info_list_; 725d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Provides a level of indirection for the test list to allow easy 726d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // shuffling and restoring the test order. The i-th element in this 727d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // vector is the index of the i-th test in the shuffled test list. 728d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const internal::scoped_ptr<internal::Vector<int> > test_indices_; 729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Pointer to the function that sets up the test case. 730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::SetUpTestCaseFunc set_up_tc_; 731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Pointer to the function that tears down the test case. 732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::TearDownTestCaseFunc tear_down_tc_; 733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // True iff any test in this test case should run. 734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_run_; 735fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Elapsed time, in milliseconds. 736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time_; 737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We disallow copying TestCases. 739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase); 740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// An Environment object is capable of setting up and tearing down an 743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// environment. The user should subclass this to define his own 744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// environment(s). 745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// An Environment object does the set-up and tear-down in virtual 747fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// methods SetUp() and TearDown() instead of the constructor and the 748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// destructor, as: 749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1. You cannot safely throw from a destructor. This is a problem 751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as in some cases Google Test is used where exceptions are enabled, and 752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// we may want to implement ASSERT_* using exceptions where they are 753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// available. 754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 2. You cannot use ASSERT_* directly in a constructor or 755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// destructor. 756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass Environment { 757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The d'tor is virtual as we need to subclass Environment. 759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~Environment() {} 760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Override this to define how to set up the environment. 762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void SetUp() {} 763fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Override this to define how to tear down the environment. 765fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void TearDown() {} 766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If you see an error about overriding the following function or 768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // about it being private, you have mis-spelled SetUp() as Setup(). 769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville struct Setup_should_be_spelled_SetUp {}; 770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } 771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 773d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// The interface for tracing execution of tests. The methods are organized in 774d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// the order the corresponding events are fired. 775d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass TestEventListener { 776d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville public: 777d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual ~TestEventListener() {} 778d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 779d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired before any test activity starts. 780d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; 781d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 782d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired before each iteration of tests starts. There may be more than 783d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration 784d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // index, starting from 0. 785d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestIterationStart(const UnitTest& unit_test, 786d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int iteration) = 0; 787d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 788d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired before environment set-up for each iteration of tests starts. 789d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; 790d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 791d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after environment set-up for each iteration of tests ends. 792d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; 793d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 794d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired before the test case starts. 795d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestCaseStart(const TestCase& test_case) = 0; 796d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 797d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired before the test starts. 798d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestStart(const TestInfo& test_info) = 0; 799d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 800d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after a failed assertion or a SUCCESS(). 801d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; 802d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 803d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after the test ends. 804d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestEnd(const TestInfo& test_info) = 0; 805d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 806d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after the test case ends. 807d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestCaseEnd(const TestCase& test_case) = 0; 808d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 809d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired before environment tear-down for each iteration of tests starts. 810d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; 811d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 812d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after environment tear-down for each iteration of tests ends. 813d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; 814d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 815d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after each iteration of tests finishes. 816d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestIterationEnd(const UnitTest& unit_test, 817d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int iteration) = 0; 818d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 819d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Fired after all test activities have ended. 820d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; 821d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville}; 822d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 823d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// The convenience class for users who need to override just one or two 824d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// methods and are not concerned that a possible change to a signature of 825d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// the methods they override will not be caught during the build. For 826d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// comments about each method please see the definition of TestEventListener 827d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// above. 828d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass EmptyTestEventListener : public TestEventListener { 829d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville public: 830d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} 831d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, 832d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int /*iteration*/) {} 833d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} 834d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} 835d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} 836d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestStart(const TestInfo& /*test_info*/) {} 837d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} 838d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestEnd(const TestInfo& /*test_info*/) {} 839d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} 840d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} 841d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} 842d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, 843d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int /*iteration*/) {} 844d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} 845d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville}; 846d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 847d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// TestEventListeners lets users add listeners to track events in Google Test. 848d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass TestEventListeners { 849d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville public: 850d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListeners(); 851d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ~TestEventListeners(); 852d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 853d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Appends an event listener to the end of the list. Google Test assumes 854d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // the ownership of the listener (i.e. it will delete the listener when 855d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // the test program finishes). 856d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void Append(TestEventListener* listener); 857d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 858d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Removes the given event listener from the list and returns it. It then 859d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // becomes the caller's responsibility to delete the listener. Returns 860d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // NULL if the listener is not found in the list. 861d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListener* Release(TestEventListener* listener); 862d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 863d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Returns the standard listener responsible for the default console 864d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // output. Can be removed from the listeners list to shut down default 865d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // console output. Note that removing this object from the listener list 866d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // with Release transfers its ownership to the caller and makes this 867d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // function return NULL the next time. 868d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListener* default_result_printer() const { 869d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return default_result_printer_; 870d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville } 871d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 872d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Returns the standard listener responsible for the default XML output 873d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // controlled by the --gtest_output=xml flag. Can be removed from the 874d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // listeners list by users who want to shut down the default XML output 875d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // controlled by this flag and substitute it with custom one. Note that 876d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // removing this object from the listener list with Release transfers its 877d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // ownership to the caller and makes this function return NULL the next 878d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // time. 879d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListener* default_xml_generator() const { 880d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return default_xml_generator_; 881d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville } 882d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 883d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville private: 884d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class TestCase; 885d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class internal::DefaultGlobalTestPartResultReporter; 886d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class internal::NoExecDeathTest; 887d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class internal::TestEventListenersAccessor; 888d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class internal::TestInfoImpl; 889d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class internal::UnitTestImpl; 890d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 891d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Returns repeater that broadcasts the TestEventListener events to all 892d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // subscribers. 893d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListener* repeater(); 894d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 895d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Sets the default_result_printer attribute to the provided listener. 896d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // The listener is also added to the listener list and previous 897d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // default_result_printer is removed from it and deleted. The listener can 898d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // also be NULL in which case it will not be added to the list. Does 899d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // nothing if the previous and the current listener objects are the same. 900d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void SetDefaultResultPrinter(TestEventListener* listener); 901d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 902d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Sets the default_xml_generator attribute to the provided listener. The 903d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // listener is also added to the listener list and previous 904d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // default_xml_generator is removed from it and deleted. The listener can 905d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // also be NULL in which case it will not be added to the list. Does 906d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // nothing if the previous and the current listener objects are the same. 907d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void SetDefaultXmlGenerator(TestEventListener* listener); 908d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 909d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Controls whether events will be forwarded by the repeater to the 910d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // listeners in the list. 911d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bool EventForwardingEnabled() const; 912d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void SuppressEventForwarding(); 913d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 914d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // The actual list of listeners. 915d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville internal::TestEventRepeater* repeater_; 916d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Listener responsible for the standard result output. 917d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListener* default_result_printer_; 918d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Listener responsible for the creation of the XML output file. 919d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListener* default_xml_generator_; 920d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 921d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // We disallow copying TestEventListeners. 922d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); 923d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville}; 924d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A UnitTest consists of a vector of TestCases. 926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This is a singleton class. The only instance of UnitTest is 928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// created when UnitTest::GetInstance() is first called. This 929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instance is never deleted. 930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 931fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UnitTest is not copyable. 932fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 933fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This class is thread-safe as long as the methods are called 934fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// according to their specification. 935fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass UnitTest { 936fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 937fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the singleton UnitTest object. The first time this method 938fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // is called, a UnitTest object is constructed and returned. 939fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Consecutive calls will return the same object. 940fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static UnitTest* GetInstance(); 941fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 942fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Runs all tests in this UnitTest object and prints the result. 943fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns 0 if successful, or 1 otherwise. 944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This method can only be called from the main thread. 946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 947fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 948fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int Run() GTEST_MUST_USE_RESULT_; 949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the working directory when the first TEST() or TEST_F() 951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // was executed. The UnitTest object owns the string. 952fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* original_working_dir() const; 953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the TestCase object for the test that's currently running, 955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or NULL if no test is running. 956d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const TestCase* current_test_case() const; 957fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 958fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the TestInfo object for the test that's currently running, 959fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or NULL if no test is running. 960fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestInfo* current_test_info() const; 961fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 962fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the random seed used at the start of the current test run. 963fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int random_seed() const; 964fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 965fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_PARAM_TEST 966fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the ParameterizedTestCaseRegistry object used to keep track of 967fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // value-parameterized tests and instantiate and register them. 968fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 969fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 970fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::ParameterizedTestCaseRegistry& parameterized_test_registry(); 971fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PARAM_TEST 972fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 973fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of successful test cases. 974fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int successful_test_case_count() const; 975fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 976fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of failed test cases. 977fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int failed_test_case_count() const; 978fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 979fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all test cases. 980fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int total_test_case_count() const; 981fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 982fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all test cases that contain at least one test 983fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // that should run. 984fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_case_to_run_count() const; 985fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 986fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of successful tests. 987fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int successful_test_count() const; 988fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 989fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of failed tests. 990fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int failed_test_count() const; 991fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 992fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of disabled tests. 993fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int disabled_test_count() const; 994fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 995fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all tests. 996fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int total_test_count() const; 997fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 998fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of tests that should run. 999fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_to_run_count() const; 1000fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1001fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the elapsed time, in milliseconds. 1002fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time() const; 1003fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1004fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the unit test passed (i.e. all test cases passed). 1005fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Passed() const; 1006fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1007fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the unit test failed (i.e. some test case failed 1008fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or something outside of all tests failed). 1009fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Failed() const; 1010fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1011fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the i-th test case among all the test cases. i can range from 0 to 1012fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // total_test_case_count() - 1. If i is not in that range, returns NULL. 1013d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const TestCase* GetTestCase(int i) const; 1014fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1015d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Returns the list of event listeners that can be used to track events 1016d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // inside Google Test. 1017d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestEventListeners& listeners(); 1018d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1019d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville private: 1020d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Registers and returns a global test environment. When a test 1021d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // program is run, all global test environments will be set-up in 1022d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // the order they were registered. After all tests in the program 1023d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // have finished, all global test environments will be torn-down in 1024d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // the *reverse* order they were registered. 1025d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // 1026d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // The UnitTest object takes ownership of the given environment. 1027d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // 1028d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // This method can only be called from the main thread. 1029d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville Environment* AddEnvironment(Environment* env); 1030d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1031d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Adds a TestPartResult to the current TestResult object. All 1032d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) 1033d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // eventually call this to report their results. The user code 1034d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // should use the assertion macros instead of calling this directly. 1035d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void AddTestPartResult(TestPartResult::Type result_type, 1036d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const char* file_name, 1037d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int line_number, 1038d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const internal::String& message, 1039d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const internal::String& os_stack_trace); 1040d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1041d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Adds a TestProperty to the current TestResult object. If the result already 1042d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // contains a property with the same key, the value will be updated. 1043d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville void RecordPropertyForCurrentTest(const char* key, const char* value); 1044d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1045d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Gets the i-th test case among all the test cases. i can range from 0 to 1046d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // total_test_case_count() - 1. If i is not in that range, returns NULL. 1047d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestCase* GetMutableTestCase(int i); 1048d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1049d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Accessors for the implementation object. 1050d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville internal::UnitTestImpl* impl() { return impl_; } 1051d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const internal::UnitTestImpl* impl() const { return impl_; } 1052d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1053d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // These classes and funcions are friends as they need to access private 1054d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // members of UnitTest. 1055d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class Test; 1056d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville friend class internal::AssertHelper; 1057fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class internal::ScopedTrace; 1058fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend Environment* AddGlobalTestEnvironment(Environment* env); 1059fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend internal::UnitTestImpl* internal::GetUnitTestImpl(); 1060fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend void internal::ReportFailureInUnknownLocation( 1061d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestPartResult::Type result_type, 1062fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::String& message); 1063fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1064fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Creates an empty UnitTest. 1065fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTest(); 1066fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1067fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // D'tor 1068fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~UnitTest(); 1069fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1070fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Pushes a trace defined by SCOPED_TRACE() on to the per-thread 1071fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Google Test trace stack. 1072fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void PushGTestTrace(const internal::TraceInfo& trace); 1073fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1074fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Pops a trace from the per-thread Google Test trace stack. 1075fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void PopGTestTrace(); 1076fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1077fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Protects mutable state in *impl_. This is mutable as some const 1078fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // methods need to lock it too. 1079fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville mutable internal::Mutex mutex_; 1080fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1081fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Opaque implementation object. This field is never changed once 1082fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the object is constructed. We don't mark it as const here, as 1083fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // doing so will cause a warning in the constructor of UnitTest. 1084fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Mutable state in *impl_ is protected by mutex_. 1085fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::UnitTestImpl* impl_; 1086fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1087fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We disallow copying UnitTest. 1088fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); 1089fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1090fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1091fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A convenient wrapper for adding an environment for the test 1092fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// program. 1093fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1094fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// You should call this before RUN_ALL_TESTS() is called, probably in 1095fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// main(). If you use gtest_main, you need to call this before main() 1096fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// starts for it to take effect. For example, you can define a global 1097fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// variable like this: 1098fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1099fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// testing::Environment* const foo_env = 1100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// testing::AddGlobalTestEnvironment(new FooEnvironment); 1101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// However, we strongly recommend you to write your own main() and 1103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// call AddGlobalTestEnvironment() there, as relying on initialization 1104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of global variables makes the code harder to read and may cause 1105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// problems when you register multiple environments from different 1106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// translation units and the environments have dependencies among them 1107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (remember that the compiler doesn't guarantee the order in which 1108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// global variables from different translation units are initialized). 1109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Environment* AddGlobalTestEnvironment(Environment* env) { 1110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return UnitTest::GetInstance()->AddEnvironment(env); 1111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Initializes Google Test. This must be called before calling 1114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// RUN_ALL_TESTS(). In particular, it parses a command line for the 1115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// flags that Google Test recognizes. Whenever a Google Test flag is 1116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// seen, it is removed from argv, and *argc is decremented. 1117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// No value is returned. Instead, the Google Test flag variables are 1119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// updated. 1120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Calling the function for the second time has no user-visible effect. 1122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid InitGoogleTest(int* argc, char** argv); 1123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This overloaded version can be used in Windows programs compiled in 1125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UNICODE mode. 1126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid InitGoogleTest(int* argc, wchar_t** argv); 1127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 1129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These overloaded versions handle ::std::string and ::std::wstring. 1131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_STD_STRING 1132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline String FormatForFailureMessage(const ::std::string& str) { 1133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (Message() << '"' << str << '"').GetString(); 1134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_STD_STRING 1136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_STD_WSTRING 1138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline String FormatForFailureMessage(const ::std::wstring& wstr) { 1139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (Message() << "L\"" << wstr << '"').GetString(); 1140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_STD_WSTRING 1142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These overloaded versions handle ::string and ::wstring. 1144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_GLOBAL_STRING 1145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline String FormatForFailureMessage(const ::string& str) { 1146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (Message() << '"' << str << '"').GetString(); 1147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_STRING 1149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_GLOBAL_WSTRING 1151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline String FormatForFailureMessage(const ::wstring& wstr) { 1152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (Message() << "L\"" << wstr << '"').GetString(); 1153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_WSTRING 1155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc) 1157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// operand to be used in a failure message. The type (but not value) 1158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of the other operand may affect the format. This allows us to 1159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// print a char* as a raw pointer when it is compared against another 1160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// char*, and print it as a C string when it is compared against an 1161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// std::string object, for example. 1162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The default implementation ignores the type of the other operand. 1164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Some specialized versions are used to handle formatting wide or 1165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// narrow C strings. 1166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2> 1169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleString FormatForComparisonFailureMessage(const T1& value, 1170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T2& /* other_operand */) { 1171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return FormatForFailureMessage(value); 1172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The helper function for {ASSERT|EXPECT}_EQ. 1175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2> 1176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperEQ(const char* expected_expression, 1177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T1& expected, 1179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T2& actual) { 1180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 1181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(push) // Saves the current warning state. 1182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(disable:4389) // Temporarily disables warning on 1183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // signed/unsigned mismatch. 1184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (expected == actual) { 1187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return AssertionSuccess(); 1188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 1191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(pop) // Restores the warning state. 1192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return EqFailure(expected_expression, 1195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville actual_expression, 1196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FormatForComparisonFailureMessage(expected, actual), 1197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FormatForComparisonFailureMessage(actual, expected), 1198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville false); 1199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// With this overloaded version, we allow anonymous enums to be used 1202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums 1203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// can be implicitly cast to BiggestInt. 1204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperEQ(const char* expected_expression, 1205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestInt expected, 1207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestInt actual); 1208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The helper class for {ASSERT|EXPECT}_EQ. The template argument 1210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// lhs_is_null_literal is true iff the first argument to ASSERT_EQ() 1211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is a null pointer literal. The following default implementation is 1212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// for lhs_is_null_literal being false. 1213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <bool lhs_is_null_literal> 1214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass EqHelper { 1215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This templatized version is for the general case. 1217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename T1, typename T2> 1218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static AssertionResult Compare(const char* expected_expression, 1219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T1& expected, 1221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T2& actual) { 1222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return CmpHelperEQ(expected_expression, actual_expression, expected, 1223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville actual); 1224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // With this overloaded version, we allow anonymous enums to be used 1227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous 1228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // enums can be implicitly cast to BiggestInt. 1229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 1230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Even though its body looks the same as the above version, we 1231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // cannot merge the two, as it will make anonymous enums unhappy. 1232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static AssertionResult Compare(const char* expected_expression, 1233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestInt expected, 1235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestInt actual) { 1236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return CmpHelperEQ(expected_expression, actual_expression, expected, 1237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville actual); 1238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This specialization is used when the first argument to ASSERT_EQ() 1242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is a null pointer literal. 1243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <> 1244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass EqHelper<true> { 1245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We define two overloaded versions of Compare(). The first 1247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // version will be picked when the second argument to ASSERT_EQ() is 1248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or 1249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // EXPECT_EQ(false, a_bool). 1250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename T1, typename T2> 1251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static AssertionResult Compare(const char* expected_expression, 1252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T1& expected, 1254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T2& actual) { 1255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return CmpHelperEQ(expected_expression, actual_expression, expected, 1256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville actual); 1257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This version will be picked when the second argument to 1260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // ASSERT_EQ() is a pointer, e.g. ASSERT_EQ(NULL, a_pointer). 1261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename T1, typename T2> 1262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static AssertionResult Compare(const char* expected_expression, 1263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T1& /* expected */, 1265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T2* actual) { 1266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We already know that 'expected' is a null pointer. 1267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return CmpHelperEQ(expected_expression, actual_expression, 1268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static_cast<T2*>(NULL), actual); 1269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A macro for implementing the helper functions needed to implement 1273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste 1274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of similar code. 1275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For each templatized helper function, we also define an overloaded 1277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// version for BiggestInt in order to reduce code bloat and allow 1278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled 1279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// with gcc 4. 1280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ 1283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2>\ 1284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ 1285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T1& val1, const T2& val2) {\ 1286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (val1 op val2) {\ 1287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return AssertionSuccess();\ 1288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } else {\ 1289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg;\ 1290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg << "Expected: (" << expr1 << ") " #op " (" << expr2\ 1291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ 1292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << " vs " << FormatForComparisonFailureMessage(val2, val1);\ 1293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return AssertionFailure(msg);\ 1294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }\ 1295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}\ 1296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ 1297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestInt val1, BiggestInt val2); 1298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Implements the helper function for {ASSERT|EXPECT}_NE 1302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_IMPL_CMP_HELPER_(NE, !=) 1303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Implements the helper function for {ASSERT|EXPECT}_LE 1304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_IMPL_CMP_HELPER_(LE, <=) 1305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Implements the helper function for {ASSERT|EXPECT}_LT 1306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_IMPL_CMP_HELPER_(LT, < ) 1307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Implements the helper function for {ASSERT|EXPECT}_GE 1308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_IMPL_CMP_HELPER_(GE, >=) 1309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Implements the helper function for {ASSERT|EXPECT}_GT 1310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_IMPL_CMP_HELPER_(GT, > ) 1311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GTEST_IMPL_CMP_HELPER_ 1313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The helper function for {ASSERT|EXPECT}_STREQ. 1315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperSTREQ(const char* expected_expression, 1318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* expected, 1320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual); 1321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The helper function for {ASSERT|EXPECT}_STRCASEEQ. 1323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, 1326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* expected, 1328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual); 1329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The helper function for {ASSERT|EXPECT}_STRNE. 1331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperSTRNE(const char* s1_expression, 1334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s2_expression, 1335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s1, 1336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s2); 1337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The helper function for {ASSERT|EXPECT}_STRCASENE. 1339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperSTRCASENE(const char* s1_expression, 1342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s2_expression, 1343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s1, 1344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s2); 1345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Helper function for *_STREQ on wide strings. 1348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperSTREQ(const char* expected_expression, 1351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const wchar_t* expected, 1353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const wchar_t* actual); 1354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Helper function for *_STRNE on wide strings. 1356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperSTRNE(const char* s1_expression, 1359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* s2_expression, 1360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const wchar_t* s1, 1361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const wchar_t* s2); 1362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// IsSubstring() and IsNotSubstring() are intended to be used as the 1366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by 1367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// themselves. They check whether needle is a substring of haystack 1368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (NULL is considered a substring of itself only), and return an 1369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// appropriate error message when they fail. 1370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The {needle,haystack}_expr arguments are the stringified 1372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// expressions that generated the two real arguments. 1373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsSubstring( 1374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle, const char* haystack); 1376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsSubstring( 1377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const wchar_t* needle, const wchar_t* haystack); 1379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsNotSubstring( 1380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle, const char* haystack); 1382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsNotSubstring( 1383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const wchar_t* needle, const wchar_t* haystack); 1385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_STD_STRING 1386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsSubstring( 1387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::std::string& needle, const ::std::string& haystack); 1389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsNotSubstring( 1390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::std::string& needle, const ::std::string& haystack); 1392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_STD_STRING 1393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_STD_WSTRING 1395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsSubstring( 1396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::std::wstring& needle, const ::std::wstring& haystack); 1398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult IsNotSubstring( 1399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* needle_expr, const char* haystack_expr, 1400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::std::wstring& needle, const ::std::wstring& haystack); 1401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_STD_WSTRING 1402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 1404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Helper template function for comparing floating-points. 1406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Template parameter: 1408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// RawType: the raw floating-point type (either float or double) 1410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename RawType> 1413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult CmpHelperFloatingPointEQ(const char* expected_expression, 1414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* actual_expression, 1415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville RawType expected, 1416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville RawType actual) { 1417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const FloatingPoint<RawType> lhs(expected), rhs(actual); 1418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (lhs.AlmostEquals(rhs)) { 1420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return AssertionSuccess(); 1421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville StrStream expected_ss; 1424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << expected; 1426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville StrStream actual_ss; 1428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) 1429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << actual; 1430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return EqFailure(expected_expression, 1432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville actual_expression, 1433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville StrStreamToString(&expected_ss), 1434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville StrStreamToString(&actual_ss), 1435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville false); 1436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Helper function for implementing ASSERT_NEAR. 1439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 1441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult DoubleNearPredFormat(const char* expr1, 1442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* expr2, 1443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* abs_error_expr, 1444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville double val1, 1445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville double val2, 1446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville double abs_error); 1447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 1449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A class that enables one to stream messages to assertion macros 1450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass AssertHelper { 1451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Constructor. 1453d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville AssertHelper(TestPartResult::Type type, 1454d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const char* file, 1455d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int line, 1456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* message); 1457d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ~AssertHelper(); 1458d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Message assignment is a semantic trick to enable assertion 1460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // streaming; see the GTEST_MESSAGE_ macro below. 1461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void operator=(const Message& message) const; 1462d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1464d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // We put our data in a struct so that the size of the AssertHelper class can 1465d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // be as small as possible. This is important because gcc is incapable of 1466d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // re-using stack space even for temporary variables, so every EXPECT_EQ 1467d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // reserves stack space for another AssertHelper. 1468d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville struct AssertHelperData { 1469d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville AssertHelperData(TestPartResult::Type t, 1470d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const char* srcfile, 1471d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int line_num, 1472d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const char* msg) 1473d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville : type(t), file(srcfile), line(line_num), message(msg) { } 1474d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1475d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville TestPartResult::Type const type; 1476d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const char* const file; 1477d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int const line; 1478d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville String const message; 1479d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1480d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville private: 1481d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); 1482d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville }; 1483d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1484d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville AssertHelperData* const data_; 1485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); 1487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_PARAM_TEST 1492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The abstract base class that all value-parameterized tests inherit from. 1493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This class adds support for accessing the test parameter value via 1495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the GetParam() method. 1496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Use it with one of the parameter generator defining functions, like Range(), 1498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Values(), ValuesIn(), Bool(), and Combine(). 1499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// class FooTest : public ::testing::TestWithParam<int> { 1501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// protected: 1502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FooTest() { 1503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Can use GetParam() here. 1504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// virtual ~FooTest() { 1506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Can use GetParam() here. 1507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// virtual void SetUp() { 1509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Can use GetParam() here. 1510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// virtual void TearDown { 1512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Can use GetParam() here. 1513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// }; 1515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TEST_P(FooTest, DoesBar) { 1516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Can use GetParam() method here. 1517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Foo foo; 1518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_TRUE(foo.DoesBar(GetParam())); 1519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); 1521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 1523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestWithParam : public Test { 1524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef T ParamType; 1526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The current parameter value. Is also available in the test fixture's 1528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // constructor. 1529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamType& GetParam() const { return *parameter_; } 1530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets parameter value. The caller is responsible for making sure the value 1533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // remains alive and unchanged throughout the current test. 1534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void SetParam(const ParamType* parameter) { 1535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville parameter_ = parameter; 1536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Static value used for accessing parameter during a test lifetime. 1539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static const ParamType* parameter_; 1540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TestClass must be a subclass of TestWithParam<T>. 1542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <class TestClass> friend class internal::ParameterizedTestFactory; 1543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 1546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst T* TestWithParam<T>::parameter_ = NULL; 1547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PARAM_TEST 1549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for indicating success/failure in test code. 1551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ADD_FAILURE unconditionally adds a failure to the current test. 1553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SUCCEED generates a success - it doesn't automatically make the 1554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// current test successful, as a test is only successful when it has 1555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// no failure. 1556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_* verifies that a certain condition is satisfied. If not, 1558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// it behaves like ADD_FAILURE. In particular: 1559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_TRUE verifies that a Boolean condition is true. 1561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_FALSE verifies that a Boolean condition is false. 1562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except 1564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// that they will also abort the current function on failure. People 1565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// usually want the fail-fast behavior of FAIL and ASSERT_*, but those 1566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// writing data-driven tests often find themselves using ADD_FAILURE 1567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and EXPECT_* more. 1568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Examples: 1570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_TRUE(server.StatusIsOK()); 1572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_FALSE(server.HasPendingRequest(port)) 1573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// << "There are still pending requests " << "on port " << port; 1574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Generates a nonfatal failure with a generic message. 1576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") 1577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Generates a fatal failure with a generic message. 1579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define FAIL() GTEST_FATAL_FAILURE_("Failed") 1580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Generates a success with a generic message. 1582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define SUCCEED() GTEST_SUCCESS_("Succeeded") 1583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for testing exceptions. 1585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_THROW(statement, expected_exception): 1587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the statement throws the expected exception. 1588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_NO_THROW(statement): 1589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the statement doesn't throw any exception. 1590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_ANY_THROW(statement): 1591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the statement throws an exception. 1592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_THROW(statement, expected_exception) \ 1594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) 1595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_NO_THROW(statement) \ 1596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) 1597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_ANY_THROW(statement) \ 1598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) 1599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_THROW(statement, expected_exception) \ 1600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) 1601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_NO_THROW(statement) \ 1602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) 1603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_ANY_THROW(statement) \ 1604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) 1605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Boolean assertions. 1607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_TRUE(condition) \ 1608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ 1609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_NONFATAL_FAILURE_) 1610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_FALSE(condition) \ 1611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ 1612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_NONFATAL_FAILURE_) 1613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_TRUE(condition) \ 1614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ 1615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FATAL_FAILURE_) 1616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_FALSE(condition) \ 1617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ 1618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FATAL_FAILURE_) 1619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Includes the auto-generated header that implements a family of 1621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// generic predicate assertion macros. 1622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest_pred_impl.h> 1623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for testing equalities and inequalities. 1625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual 1627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 1628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 1629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 1630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 1631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 1632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When they are not, Google Test prints both the tested expressions and 1634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// their actual values. The values must be compatible built-in types, 1635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// or you will get a compiler error. By "compatible" we mean that the 1636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// values can be compared by the respective operator. 1637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Note: 1639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1. It is possible to make a user-defined type work with 1641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// {ASSERT|EXPECT}_??(), but that requires overloading the 1642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// comparison operators and is thus discouraged by the Google C++ 1643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Usage Guide. Therefore, you are advised to use the 1644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// {ASSERT|EXPECT}_TRUE() macro to assert that two objects are 1645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// equal. 1646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on 1648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// pointers (in particular, C strings). Therefore, if you use it 1649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// with two C strings, you are testing how their locations in memory 1650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// are related, not how their content is related. To compare two C 1651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strings by content, use {ASSERT|EXPECT}_STR*(). 1652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to 1654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you 1655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// what the actual value is when it fails, and similarly for the 1656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// other comparisons. 1657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 4. Do not depend on the order in which {ASSERT|EXPECT}_??() 1659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// evaluate their arguments, which is undefined. 1660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 5. These macros evaluate their arguments exactly once. 1662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Examples: 1664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_NE(5, Foo()); 1666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_EQ(NULL, a_pointer); 1667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_LT(i, array_size); 1668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_GT(records.size(), 0) << "There is no record left."; 1669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_EQ(expected, actual) \ 1671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal:: \ 1672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \ 1673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected, actual) 1674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_NE(expected, actual) \ 1675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual) 1676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_LE(val1, val2) \ 1677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) 1678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_LT(val1, val2) \ 1679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) 1680fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_GE(val1, val2) \ 1681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) 1682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_GT(val1, val2) \ 1683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) 1684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_EQ(expected, actual) \ 1686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal:: \ 1687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \ 1688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected, actual) 1689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_NE(val1, val2) \ 1690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) 1691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_LE(val1, val2) \ 1692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) 1693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_LT(val1, val2) \ 1694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) 1695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_GE(val1, val2) \ 1696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) 1697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_GT(val1, val2) \ 1698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) 1699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// C String Comparisons. All tests treat NULL and any non-NULL string 1701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as different. Two NULLs are equal. 1702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 1704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 1705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case 1706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case 1707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For wide or narrow string objects, you can use the 1709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// {ASSERT|EXPECT}_??() macros. 1710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Don't depend on the order in which the arguments are evaluated, 1712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// which is undefined. 1713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These macros evaluate their arguments exactly once. 1715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_STREQ(expected, actual) \ 1717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) 1718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_STRNE(s1, s2) \ 1719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) 1720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_STRCASEEQ(expected, actual) \ 1721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) 1722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_STRCASENE(s1, s2)\ 1723fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) 1724fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_STREQ(expected, actual) \ 1726fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) 1727fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_STRNE(s1, s2) \ 1728fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) 1729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_STRCASEEQ(expected, actual) \ 1730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) 1731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_STRCASENE(s1, s2)\ 1732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) 1733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for comparing floating-point numbers. 1735fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual): 1737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that two float values are almost equal. 1738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual): 1739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that two double values are almost equal. 1740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): 1741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that v1 and v2 are within the given distance to each other. 1742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Google Test uses ULP-based comparison to automatically pick a default 1744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// error bound that is appropriate for the operands. See the 1745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FloatingPoint template class in gtest-internal.h if you are 1746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// interested in the implementation details. 1747fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_FLOAT_EQ(expected, actual)\ 1749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ 1750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected, actual) 1751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_DOUBLE_EQ(expected, actual)\ 1753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ 1754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected, actual) 1755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_FLOAT_EQ(expected, actual)\ 1757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ 1758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected, actual) 1759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_DOUBLE_EQ(expected, actual)\ 1761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ 1762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected, actual) 1763fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_NEAR(val1, val2, abs_error)\ 1765fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ 1766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville val1, val2, abs_error) 1767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_NEAR(val1, val2, abs_error)\ 1769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ 1770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville val1, val2, abs_error) 1771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These predicate format functions work on floating-point values, and 1773fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. 1774fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1775fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); 1776fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1777fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Asserts that val1 is less than, or almost equal to, val2. Fails 1778fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// otherwise. In particular, it fails if either val1 or val2 is NaN. 1779fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult FloatLE(const char* expr1, const char* expr2, 1780fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville float val1, float val2); 1781fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleAssertionResult DoubleLE(const char* expr1, const char* expr2, 1782fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville double val1, double val2); 1783fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1784fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros that test for HRESULT failure and success, these are only useful 1788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// on Windows, and rely on Windows SDK macros and APIs to compile. 1789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) 1791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When expr unexpectedly fails or succeeds, Google Test prints the 1793fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// expected result and the actual result with both a human-readable 1794fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// string representation of the error, if available, as well as the 1795fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// hex result code. 1796fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_HRESULT_SUCCEEDED(expr) \ 1797fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) 1798fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1799fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_HRESULT_SUCCEEDED(expr) \ 1800fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) 1801fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1802fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_HRESULT_FAILED(expr) \ 1803fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) 1804fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1805fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_HRESULT_FAILED(expr) \ 1806fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) 1807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros that execute statement and check that it doesn't generate new fatal 1811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// failures in the current thread. 1812fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); 1814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Examples: 1816fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1817fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_NO_FATAL_FAILURE(Process()); 1818fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; 1819fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1820fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define ASSERT_NO_FATAL_FAILURE(statement) \ 1821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) 1822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define EXPECT_NO_FATAL_FAILURE(statement) \ 1823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) 1824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Causes a trace (including the source file path, the current line 1826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// number, and the given message) to be included in every test failure 1827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// message generated by code in the current scope. The effect is 1828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// undone when the control leaves the current scope. 1829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The message argument can be anything streamable to std::ostream. 1831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In the implementation, we include the current line number as part 1833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s 1834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to appear in the same block - as long as they are on different 1835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// lines. 1836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define SCOPED_TRACE(message) \ 1837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ 1838fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville __FILE__, __LINE__, ::testing::Message() << (message)) 1839fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1840fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 1841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This template is declared, but intentionally undefined. 1843fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2> 1844fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct StaticAssertTypeEqHelper; 1845fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1846fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 1847fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct StaticAssertTypeEqHelper<T, T> {}; 1848fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1849fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1850fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1851fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Compile-time assertion for type equality. 1852fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are 1853fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the same type. The value it returns is not interesting. 1854fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1855fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Instead of making StaticAssertTypeEq a class template, we make it a 1856fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// function template that invokes a helper class template. This 1857fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// prevents a user from misusing StaticAssertTypeEq<T1, T2> by 1858fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// defining objects of that type. 1859fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1860fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// CAVEAT: 1861fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1862fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When used inside a method of a class template, 1863fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is 1864fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instantiated. For example, given: 1865fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1866fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// template <typename T> class Foo { 1867fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// public: 1868fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void Bar() { testing::StaticAssertTypeEq<int, T>(); } 1869fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// }; 1870fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1871fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the code: 1872fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1873fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void Test1() { Foo<bool> foo; } 1874fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1875fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// will NOT generate a compiler error, as Foo<bool>::Bar() is never 1876fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// actually instantiated. Instead, you need: 1877fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1878fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void Test2() { Foo<bool> foo; foo.Bar(); } 1879fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1880fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to cause a compiler error. 1881fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2> 1882fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool StaticAssertTypeEq() { 1883fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::StaticAssertTypeEqHelper<T1, T2>(); 1884fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return true; 1885fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1886fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1887fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines a test. 1888fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1889fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The first parameter is the name of the test case, and the second 1890fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// parameter is the name of the test within the test case. 1891fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1892fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The convention is to end the test case name with "Test". For 1893fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// example, a test case for the Foo class can be named FooTest. 1894fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1895fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user should put his test code between braces after using this 1896fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// macro. Example: 1897fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1898fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TEST(FooTest, InitializesCorrectly) { 1899fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Foo foo; 1900fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_TRUE(foo.StatusIsOK()); 1901fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1902fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1903fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Note that we call GetTestTypeId() instead of GetTypeId< 1904fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ::testing::Test>() here to get the type ID of testing::Test. This 1905fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is to work around a suspected linker bug when using Google Test as 1906fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a framework on Mac OS X. The bug causes GetTypeId< 1907fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ::testing::Test>() to return different values depending on whether 1908fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the call is from the Google Test framework itself or from user test 1909fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// code. GetTestTypeId() is guaranteed to always return the same 1910fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// value, as it always calls GetTypeId<>() from the Google Test 1911fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// framework. 1912fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define TEST(test_case_name, test_name)\ 1913fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_(test_case_name, test_name, \ 1914fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::testing::Test, ::testing::internal::GetTestTypeId()) 1915fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1916fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1917fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines a test that uses a test fixture. 1918fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1919fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The first parameter is the name of the test fixture class, which 1920fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// also doubles as the test case name. The second parameter is the 1921fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// name of the test within the test case. 1922fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1923fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A test fixture class must be declared earlier. The user should put 1924fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// his test code between braces after using this macro. Example: 1925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// class FooTest : public testing::Test { 1927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// protected: 1928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// virtual void SetUp() { b_.AddElement(3); } 1929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Foo a_; 1931fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Foo b_; 1932fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// }; 1933fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1934fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TEST_F(FooTest, InitializesCorrectly) { 1935fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_TRUE(a_.StatusIsOK()); 1936fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1937fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1938fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TEST_F(FooTest, ReturnsElementCountCorrectly) { 1939fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_EQ(0, a_.size()); 1940fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// EXPECT_EQ(1, b_.size()); 1941fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 1942fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1943fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define TEST_F(test_fixture, test_name)\ 1944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_TEST_(test_fixture, test_name, test_fixture, \ 1945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::testing::internal::GetTypeId<test_fixture>()) 1946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1947fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Use this macro in main() to run all tests. It returns 0 if all 1948fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// tests are successful, or 1 otherwise. 1949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// RUN_ALL_TESTS() should be invoked after the command line has been 1951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// parsed by InitGoogleTest(). 1952fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define RUN_ALL_TESTS()\ 1954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (::testing::UnitTest::GetInstance()->Run()) 1955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1956fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace testing 1957fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1958fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_INCLUDE_GTEST_GTEST_H_ 1959