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