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