gtest-internal.h revision 735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9b
1735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Copyright 2005, Google Inc. 2735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// All rights reserved. 3735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 4735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Redistribution and use in source and binary forms, with or without 5735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// modification, are permitted provided that the following conditions are 6735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// met: 7735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 8735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// * Redistributions of source code must retain the above copyright 9735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// notice, this list of conditions and the following disclaimer. 10735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// * Redistributions in binary form must reproduce the above 11735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// copyright notice, this list of conditions and the following disclaimer 12735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// in the documentation and/or other materials provided with the 13735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// distribution. 14735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// * Neither the name of Google Inc. nor the names of its 15735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// contributors may be used to endorse or promote products derived from 16735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// this software without specific prior written permission. 17735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 18735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 30735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) 31735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 32735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The Google C++ Testing Framework (Google Test) 33735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 34735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This header file declares functions and macros used internally by 35735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Google Test. They are subject to change without notice. 36735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 37735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 38735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 39735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 40735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include "gtest/internal/gtest-port.h" 41735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 42735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#if GTEST_OS_LINUX 43735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# include <stdlib.h> 44735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# include <sys/types.h> 45735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# include <sys/wait.h> 46735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# include <unistd.h> 47735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // GTEST_OS_LINUX 48735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 49735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#if GTEST_HAS_EXCEPTIONS 50735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# include <stdexcept> 51735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif 52735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 53735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include <ctype.h> 54735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include <string.h> 55735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include <iomanip> 56735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include <limits> 57735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include <set> 58735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 59735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include "gtest/gtest-message.h" 60735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include "gtest/internal/gtest-string.h" 61735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include "gtest/internal/gtest-filepath.h" 62735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#include "gtest/internal/gtest-type-util.h" 63735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 64735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Due to C++ preprocessor weirdness, we need double indirection to 65735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// concatenate two tokens when one of them is __LINE__. Writing 66735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 67735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// foo ## __LINE__ 68735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 69735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// will result in the token foo__LINE__, instead of foo followed by 70735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the current line number. For more details, see 71735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 72735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) 73735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar 74735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 75735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass ProtocolMessage; 76735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnernamespace proto2 { class Message; } 77735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 78735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnernamespace testing { 79735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 80735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Forward declarations. 81735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 82735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass AssertionResult; // Result of an assertion. 83735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass Message; // Represents a failure message. 84735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass Test; // Represents a test. 85735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TestInfo; // Information about a test. 86735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TestPartResult; // Result of a test part. 87735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass UnitTest; // A collection of test cases. 88735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 89735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 90735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner::std::string PrintToString(const T& value); 91735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 92735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnernamespace internal { 93735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 94735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct TraceInfo; // Information about a trace point. 95735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass ScopedTrace; // Implements scoped trace. 96735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TestInfoImpl; // Opaque implementation of TestInfo 97735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass UnitTestImpl; // Opaque implementation of UnitTest 98735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 99735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// How many times InitGoogleTest() has been called. 100735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ extern int g_init_gtest_count; 101735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 102735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The text used in failure messages to indicate the start of the 103735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// stack trace. 104735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ extern const char kStackTraceMarker[]; 105735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 106735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Two overloaded helpers for checking at compile time whether an 107735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// expression is a null pointer literal (i.e. NULL or any 0-valued 108735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// compile-time integral constant). Their return values have 109735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// different sizes, so we can use sizeof() to test which version is 110735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// picked by the compiler. These helpers have no implementations, as 111735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// we only need their signatures. 112735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 113735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Given IsNullLiteralHelper(x), the compiler will pick the first 114735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// version if x can be implicitly converted to Secret*, and pick the 115735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// second version otherwise. Since Secret is a secret and incomplete 116735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// type, the only expression a user can write that has type Secret* is 117735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// a null pointer literal. Therefore, we know that x is a null 118735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// pointer literal if and only if the first version is picked by the 119735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// compiler. 120735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerchar IsNullLiteralHelper(Secret* p); 121735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerchar (&IsNullLiteralHelper(...))[2]; // NOLINT 122735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 123735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A compile-time bool constant that is true if and only if x is a 124735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// null pointer literal (i.e. NULL or any 0-valued compile-time 125735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// integral constant). 126735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#ifdef GTEST_ELLIPSIS_NEEDS_POD_ 127735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// We lose support for NULL detection where the compiler doesn't like 128735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// passing non-POD classes through ellipsis (...). 129735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# define GTEST_IS_NULL_LITERAL_(x) false 130735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#else 131735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# define GTEST_IS_NULL_LITERAL_(x) \ 132735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) 133735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // GTEST_ELLIPSIS_NEEDS_POD_ 134735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 135735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Appends the user-supplied message to the Google-Test-generated message. 136735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ std::string AppendUserMessage( 137735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const std::string& gtest_msg, const Message& user_msg); 138735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 139735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#if GTEST_HAS_EXCEPTIONS 140735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 141735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This exception is thrown by (and only by) a failed Google Test 142735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions 143735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// are enabled). We derive it from std::runtime_error, which is for 144735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// errors presumably detectable only at run time. Since 145735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// std::runtime_error inherits from std::exception, many testing 146735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// frameworks know how to extract and print the message inside it. 147735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass GTEST_API_ GoogleTestFailureException : public ::std::runtime_error { 148735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 149735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner explicit GoogleTestFailureException(const TestPartResult& failure); 150735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 151735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 152735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // GTEST_HAS_EXCEPTIONS 153735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 154735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A helper class for creating scoped traces in user programs. 155735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass GTEST_API_ ScopedTrace { 156735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 157735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The c'tor pushes the given source file location and message onto 158735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // a trace stack maintained by Google Test. 159735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ScopedTrace(const char* file, int line, const Message& message); 160735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 161735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The d'tor pops the info pushed by the c'tor. 162735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 163735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Note that the d'tor is not virtual in order to be efficient. 164735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Don't inherit from ScopedTrace! 165735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ~ScopedTrace(); 166735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 167735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 168735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); 169735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its 170735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // c'tor and d'tor. Therefore it doesn't 171735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // need to be used otherwise. 172735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 173735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Constructs and returns the message for an equality assertion 174735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. 175735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 176735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The first four parameters are the expressions used in the assertion 177735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// and their values, as strings. For example, for ASSERT_EQ(foo, bar) 178735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// where foo is 5 and bar is 6, we have: 179735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 180735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// expected_expression: "foo" 181735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// actual_expression: "bar" 182735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// expected_value: "5" 183735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// actual_value: "6" 184735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 185735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The ignoring_case parameter is true iff the assertion is a 186735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will 187735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// be inserted into the message. 188735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ AssertionResult EqFailure(const char* expected_expression, 189735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* actual_expression, 190735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const std::string& expected_value, 191735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const std::string& actual_value, 192735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool ignoring_case); 193735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 194735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. 195735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ std::string GetBoolAssertionFailureMessage( 196735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const AssertionResult& assertion_result, 197735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* expression_text, 198735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* actual_predicate_value, 199735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* expected_predicate_value); 200735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 201735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This template class represents an IEEE floating-point number 202735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// (either single-precision or double-precision, depending on the 203735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// template parameters). 204735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 205735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The purpose of this class is to do more sophisticated number 206735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// comparison. (Due to round-off error, etc, it's very unlikely that 207735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// two floating-points will be equal exactly. Hence a naive 208735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// comparison by the == operation often doesn't work.) 209735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 210735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Format of IEEE floating-point: 211735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 212735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The most-significant bit being the leftmost, an IEEE 213735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// floating-point looks like 214735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 215735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// sign_bit exponent_bits fraction_bits 216735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 217735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Here, sign_bit is a single bit that designates the sign of the 218735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// number. 219735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 220735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// For float, there are 8 exponent bits and 23 fraction bits. 221735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 222735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// For double, there are 11 exponent bits and 52 fraction bits. 223735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 224735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// More details can be found at 225735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// http://en.wikipedia.org/wiki/IEEE_floating-point_standard. 226735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 227735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Template parameter: 228735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 229735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// RawType: the raw floating-point type (either float or double) 230735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename RawType> 231735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass FloatingPoint { 232735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 233735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Defines the unsigned integer type that has the same size as the 234735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // floating point number. 235735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits; 236735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 237735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Constants. 238735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 239735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // # of bits in a number. 240735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const size_t kBitCount = 8*sizeof(RawType); 241735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 242735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // # of fraction bits in a number. 243735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const size_t kFractionBitCount = 244735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner std::numeric_limits<RawType>::digits - 1; 245735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 246735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // # of exponent bits in a number. 247735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; 248735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 249735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The mask for the sign bit. 250735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1); 251735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 252735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The mask for the fraction bits. 253735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const Bits kFractionBitMask = 254735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ~static_cast<Bits>(0) >> (kExponentBitCount + 1); 255735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 256735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The mask for the exponent bits. 257735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); 258735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 259735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // How many ULP's (Units in the Last Place) we want to tolerate when 260735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // comparing two numbers. The larger the value, the more error we 261735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // allow. A 0 value means that two numbers must be exactly the same 262735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // to be considered equal. 263735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 264735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The maximum error of a single floating-point operation is 0.5 265735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // units in the last place. On Intel CPU's, all floating-point 266735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // calculations are done with 80-bit precision, while double has 64 267735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // bits. Therefore, 4 should be enough for ordinary use. 268735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 269735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // See the following article for more details on ULP: 270735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ 271735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const size_t kMaxUlps = 4; 272735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 273735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Constructs a FloatingPoint from a raw floating-point number. 274735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 275735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // On an Intel CPU, passing a non-normalized NAN (Not a Number) 276735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // around may change its bits, although the new value is guaranteed 277735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // to be also a NAN. Therefore, don't expect this constructor to 278735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // preserve the bits in x when x is a NAN. 279735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner explicit FloatingPoint(const RawType& x) { u_.value_ = x; } 280735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 281735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Static methods 282735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 283735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Reinterprets a bit pattern as a floating-point number. 284735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 285735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // This function is needed to test the AlmostEquals() method. 286735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static RawType ReinterpretBits(const Bits bits) { 287735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner FloatingPoint fp(0); 288735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fp.u_.bits_ = bits; 289735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return fp.u_.value_; 290735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 291735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 292735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns the floating-point number that represent positive infinity. 293735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static RawType Infinity() { 294735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return ReinterpretBits(kExponentBitMask); 295735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 296735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 297735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Non-static methods 298735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 299735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns the bits that represents this number. 300735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const Bits &bits() const { return u_.bits_; } 301735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 302735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns the exponent bits of this number. 303735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } 304735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 305735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns the fraction bits of this number. 306735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } 307735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 308735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns the sign bit of this number. 309735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Bits sign_bit() const { return kSignBitMask & u_.bits_; } 310735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 311735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns true iff this is NAN (not a number). 312735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool is_nan() const { 313735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // It's a NAN if the exponent bits are all ones and the fraction 314735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // bits are not entirely zeros. 315735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); 316735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 317735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 318735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Returns true iff this number is at most kMaxUlps ULP's away from 319735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // rhs. In particular, this function: 320735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 321735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // - returns false if either number is (or both are) NAN. 322735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // - treats really large numbers as almost equal to infinity. 323735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // - thinks +0.0 and -0.0 are 0 DLP's apart. 324735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool AlmostEquals(const FloatingPoint& rhs) const { 325735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The IEEE standard says that any comparison operation involving 326735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // a NAN must return false. 327735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (is_nan() || rhs.is_nan()) return false; 328735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 329735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) 330735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner <= kMaxUlps; 331735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 332735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 333735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 334735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The data type used to store the actual floating-point number. 335735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner union FloatingPointUnion { 336735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner RawType value_; // The raw floating-point number. 337735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Bits bits_; // The bits that represent the number. 338735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner }; 339735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 340735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Converts an integer from the sign-and-magnitude representation to 341735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // the biased representation. More precisely, let N be 2 to the 342735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // power of (kBitCount - 1), an integer x is represented by the 343735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // unsigned number x + N. 344735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 345735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // For instance, 346735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 347735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // -N + 1 (the most negative number representable using 348735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // sign-and-magnitude) is represented by 1; 349735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 0 is represented by N; and 350735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // N - 1 (the biggest number representable using 351735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // sign-and-magnitude) is represented by 2N - 1. 352735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 353735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Read http://en.wikipedia.org/wiki/Signed_number_representations 354735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // for more details on signed number representations. 355735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static Bits SignAndMagnitudeToBiased(const Bits &sam) { 356735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (kSignBitMask & sam) { 357735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // sam represents a negative number. 358735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return ~sam + 1; 359735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } else { 360735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // sam represents a positive number. 361735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return kSignBitMask | sam; 362735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 363735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 364735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 365735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Given two numbers in the sign-and-magnitude representation, 366735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // returns the distance between them as an unsigned number. 367735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, 368735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const Bits &sam2) { 369735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const Bits biased1 = SignAndMagnitudeToBiased(sam1); 370735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const Bits biased2 = SignAndMagnitudeToBiased(sam2); 371735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); 372735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 373735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 374735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner FloatingPointUnion u_; 375735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 376735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 377735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Typedefs the instances of the FloatingPoint template class that we 378735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// care to use. 379735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef FloatingPoint<float> Float; 380735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef FloatingPoint<double> Double; 381735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 382735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// In order to catch the mistake of putting tests that use different 383735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// test fixture classes in the same test case, we need to assign 384735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// unique IDs to fixture classes and compare them. The TypeId type is 385735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// used to hold such IDs. The user should treat TypeId as an opaque 386735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// type: the only operation allowed on TypeId values is to compare 387735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// them for equality using the == operator. 388735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef const void* TypeId; 389735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 390735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 391735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TypeIdHelper { 392735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 393735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // dummy_ must not have a const type. Otherwise an overly eager 394735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // compiler (e.g. MSVC 7.1 & 8.0) may try to merge 395735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // TypeIdHelper<T>::dummy_ for different Ts as an "optimization". 396735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static bool dummy_; 397735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 398735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 399735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 400735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerbool TypeIdHelper<T>::dummy_ = false; 401735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 402735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// GetTypeId<T>() returns the ID of type T. Different values will be 403735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// returned for different types. Calling the function twice with the 404735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// same type argument is guaranteed to return the same ID. 405735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 406735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerTypeId GetTypeId() { 407735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The compiler is required to allocate a different 408735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // TypeIdHelper<T>::dummy_ variable for each T used to instantiate 409735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // the template. Therefore, the address of dummy_ is guaranteed to 410735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // be unique. 411735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return &(TypeIdHelper<T>::dummy_); 412735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 413735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 414735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Returns the type ID of ::testing::Test. Always call this instead 415735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// of GetTypeId< ::testing::Test>() to get the type ID of 416735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// ::testing::Test, as the latter may give the wrong result due to a 417735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// suspected linker bug when compiling Google Test as a Mac OS X 418735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// framework. 419735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ TypeId GetTestTypeId(); 420735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 421735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Defines the abstract factory interface that creates instances 422735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// of a Test object. 423735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TestFactoryBase { 424735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 425735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner virtual ~TestFactoryBase() {} 426735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 427735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Creates a test instance to run. The instance is both created and destroyed 428735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // within TestInfoImpl::Run() 429735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner virtual Test* CreateTest() = 0; 430735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 431735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner protected: 432735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TestFactoryBase() {} 433735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 434735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 435735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); 436735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 437735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 438735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This class provides implementation of TeastFactoryBase interface. 439735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// It is used in TEST and TEST_F macros. 440735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <class TestClass> 441735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TestFactoryImpl : public TestFactoryBase { 442735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 443735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner virtual Test* CreateTest() { return new TestClass; } 444735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 445735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 446735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#if GTEST_OS_WINDOWS 447735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 448735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Predicate-formatters for implementing the HRESULT checking macros 449735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} 450735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// We pass a long instead of HRESULT to avoid causing an 451735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// include dependency for the HRESULT type. 452735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, 453735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner long hr); // NOLINT 454735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, 455735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner long hr); // NOLINT 456735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 457735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // GTEST_OS_WINDOWS 458735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 459735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Types of SetUpTestCase() and TearDownTestCase() functions. 460735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef void (*SetUpTestCaseFunc)(); 461735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef void (*TearDownTestCaseFunc)(); 462735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 463735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Creates a new TestInfo object and registers it with Google Test; 464735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// returns the created object. 465735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 466735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Arguments: 467735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 468735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// test_case_name: name of the test case 469735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// name: name of the test 470735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// type_param the name of the test's type parameter, or NULL if 471735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// this is not a typed or a type-parameterized test. 472735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// value_param text representation of the test's value parameter, 473735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// or NULL if this is not a type-parameterized test. 474735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// fixture_class_id: ID of the test fixture class 475735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// set_up_tc: pointer to the function that sets up the test case 476735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// tear_down_tc: pointer to the function that tears down the test case 477735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// factory: pointer to the factory that creates a test object. 478735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The newly created TestInfo instance will assume 479735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// ownership of the factory object. 480735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ TestInfo* MakeAndRegisterTestInfo( 481735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* test_case_name, 482735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* name, 483735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* type_param, 484735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* value_param, 485735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TypeId fixture_class_id, 486735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner SetUpTestCaseFunc set_up_tc, 487735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TearDownTestCaseFunc tear_down_tc, 488735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TestFactoryBase* factory); 489735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 490735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// If *pstr starts with the given prefix, modifies *pstr to be right 491735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// past the prefix and returns true; otherwise leaves *pstr unchanged 492735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// and returns false. None of pstr, *pstr, and prefix can be NULL. 493735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); 494735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 495735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P 496735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 497735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// State of the definition of a type-parameterized test case. 498735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass GTEST_API_ TypedTestCasePState { 499735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 500735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TypedTestCasePState() : registered_(false) {} 501735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 502735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Adds the given test name to defined_test_names_ and return true 503735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // if the test case hasn't been registered; otherwise aborts the 504735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // program. 505735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool AddTestName(const char* file, int line, const char* case_name, 506735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* test_name) { 507735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (registered_) { 508735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fprintf(stderr, "%s Test %s must be defined before " 509735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n", 510735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner FormatFileLocation(file, line).c_str(), test_name, case_name); 511735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fflush(stderr); 512735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner posix::Abort(); 513735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 514735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner defined_test_names_.insert(test_name); 515735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return true; 516735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 517735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 518735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Verifies that registered_tests match the test names in 519735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // defined_test_names_; returns registered_tests if successful, or 520735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // aborts the program otherwise. 521735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* VerifyRegisteredTestNames( 522735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* file, int line, const char* registered_tests); 523735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 524735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 525735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool registered_; 526735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::std::set<const char*> defined_test_names_; 527735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 528735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 529735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Skips to the first non-space char after the first comma in 'str'; 530735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// returns NULL if no comma is found in 'str'. 531735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline const char* SkipComma(const char* str) { 532735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* comma = strchr(str, ','); 533735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (comma == NULL) { 534735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return NULL; 535735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 536735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner while (IsSpace(*(++comma))) {} 537735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return comma; 538735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 539735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 540735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Returns the prefix of 'str' before the first comma in it; returns 541735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the entire string if it contains no comma. 542735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline std::string GetPrefixUntilComma(const char* str) { 543735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* comma = strchr(str, ','); 544735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return comma == NULL ? str : std::string(str, comma); 545735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 546735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 547735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// TypeParameterizedTest<Fixture, TestSel, Types>::Register() 548735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// registers a list of type-parameterized tests with Google Test. The 549735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// return value is insignificant - we just need to return something 550735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// such that we can call this function in a namespace scope. 551735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 552735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Implementation note: The GTEST_TEMPLATE_ macro declares a template 553735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// template parameter. It's defined in gtest-type-util.h. 554735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types> 555735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TypeParameterizedTest { 556735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 557735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 'index' is the index of the test in the type list 'Types' 558735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase, 559735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Types). Valid values for 'index' are [0, N - 1] where N is the 560735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // length of Types. 561735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static bool Register(const char* prefix, const char* case_name, 562735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* test_names, int index) { 563735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef typename Types::Head Type; 564735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef Fixture<Type> FixtureClass; 565735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef typename GTEST_BIND_(TestSel, Type) TestClass; 566735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 567735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // First, registers the first type-parameterized test in the type 568735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // list. 569735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner MakeAndRegisterTestInfo( 570735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/" 571735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner + StreamableToString(index)).c_str(), 572735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GetPrefixUntilComma(test_names).c_str(), 573735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GetTypeName<Type>().c_str(), 574735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner NULL, // No value parameter. 575735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GetTypeId<FixtureClass>(), 576735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TestClass::SetUpTestCase, 577735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TestClass::TearDownTestCase, 578735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner new TestFactoryImpl<TestClass>); 579735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 580735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Next, recurses (at compile time) with the tail of the type list. 581735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail> 582735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::Register(prefix, case_name, test_names, index + 1); 583735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 584735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 585735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 586735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The base case for the compile time recursion. 587735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <GTEST_TEMPLATE_ Fixture, class TestSel> 588735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TypeParameterizedTest<Fixture, TestSel, Types0> { 589735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 590735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static bool Register(const char* /*prefix*/, const char* /*case_name*/, 591735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* /*test_names*/, int /*index*/) { 592735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return true; 593735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 594735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 595735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 596735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// TypeParameterizedTestCase<Fixture, Tests, Types>::Register() 597735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// registers *all combinations* of 'Tests' and 'Types' with Google 598735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Test. The return value is insignificant - we just need to return 599735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// something such that we can call this function in a namespace scope. 600735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types> 601735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TypeParameterizedTestCase { 602735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 603735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static bool Register(const char* prefix, const char* case_name, 604735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* test_names) { 605735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef typename Tests::Head Head; 606735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 607735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // First, register the first test in 'Test' for each type in 'Types'. 608735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner TypeParameterizedTest<Fixture, Head, Types>::Register( 609735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner prefix, case_name, test_names, 0); 610735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 611735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Next, recurses (at compile time) with the tail of the test list. 612735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types> 613735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::Register(prefix, case_name, SkipComma(test_names)); 614735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 615735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 616735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 617735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The base case for the compile time recursion. 618735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <GTEST_TEMPLATE_ Fixture, typename Types> 619735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass TypeParameterizedTestCase<Fixture, Templates0, Types> { 620735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 621735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static bool Register(const char* /*prefix*/, const char* /*case_name*/, 622735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* /*test_names*/) { 623735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return true; 624735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 625735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 626735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 627735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P 628735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 629735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Returns the current OS stack trace as an std::string. 630735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 631735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The maximum number of stack frames to be included is specified by 632735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the gtest_stack_trace_depth flag. The skip_count parameter 633735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// specifies the number of top frames to be skipped, which doesn't 634735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// count against the number of frames to be included. 635735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 636735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// For example, if Foo() calls Bar(), which in turn calls 637735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in 638735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. 639735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ std::string GetCurrentOsStackTraceExceptTop( 640735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner UnitTest* unit_test, int skip_count); 641735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 642735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Helpers for suppressing warnings on unreachable code or constant 643735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// condition. 644735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 645735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Always returns true. 646735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerGTEST_API_ bool AlwaysTrue(); 647735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 648735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Always returns false. 649735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline bool AlwaysFalse() { return !AlwaysTrue(); } 650735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 651735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Helper for suppressing false warning from Clang on a const char* 652735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// variable declared in a conditional expression always being NULL in 653735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the else branch. 654735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct GTEST_API_ ConstCharPtr { 655735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ConstCharPtr(const char* str) : value(str) {} 656735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner operator bool() const { return true; } 657735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const char* value; 658735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 659735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 660735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A simple Linear Congruential Generator for generating random 661735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// numbers with a uniform distribution. Unlike rand() and srand(), it 662735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// doesn't use global state (and therefore can't interfere with user 663735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// code). Unlike rand_r(), it's portable. An LCG isn't very random, 664735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// but it's good enough for our purposes. 665735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass GTEST_API_ Random { 666735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 667735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const UInt32 kMaxRange = 1u << 31; 668735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 669735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner explicit Random(UInt32 seed) : state_(seed) {} 670735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 671735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner void Reseed(UInt32 seed) { state_ = seed; } 672735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 673735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Generates a random number from [0, range). Crashes if 'range' is 674735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 0 or greater than kMaxRange. 675735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner UInt32 Generate(UInt32 range); 676735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 677735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 678735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner UInt32 state_; 679735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); 680735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 681735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 682735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a 683735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// compiler error iff T1 and T2 are different types. 684735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T1, typename T2> 685735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct CompileAssertTypesEqual; 686735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 687735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 688735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct CompileAssertTypesEqual<T, T> { 689735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 690735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 691735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Removes the reference from a type if it is a reference type, 692735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// otherwise leaves it unchanged. This is the same as 693735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// tr1::remove_reference, which is not widely available yet. 694735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 695735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct RemoveReference { typedef T type; }; // NOLINT 696735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 697735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct RemoveReference<T&> { typedef T type; }; // NOLINT 698735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 699735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A handy wrapper around RemoveReference that works when the argument 700735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// T depends on template parameters. 701735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_REMOVE_REFERENCE_(T) \ 702735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typename ::testing::internal::RemoveReference<T>::type 703735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 704735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Removes const from a type if it is a const type, otherwise leaves 705735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// it unchanged. This is the same as tr1::remove_const, which is not 706735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// widely available yet. 707735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 708735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct RemoveConst { typedef T type; }; // NOLINT 709735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 710735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct RemoveConst<const T> { typedef T type; }; // NOLINT 711735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 712735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above 713735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// definition to fail to remove the const in 'const int[3]' and 'const 714735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// char[3][4]'. The following specialization works around the bug. 715735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, size_t N> 716735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct RemoveConst<const T[N]> { 717735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef typename RemoveConst<T>::type type[N]; 718735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 719735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 720735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#if defined(_MSC_VER) && _MSC_VER < 1400 721735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This is the only specialization that allows VC++ 7.1 to remove const in 722735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 'const int[3] and 'const int[3][4]'. However, it causes trouble with GCC 723735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// and thus needs to be conditionally compiled. 724735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, size_t N> 725735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct RemoveConst<T[N]> { 726735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef typename RemoveConst<T>::type type[N]; 727735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 728735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif 729735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 730735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A handy wrapper around RemoveConst that works when the argument 731735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// T depends on template parameters. 732735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_REMOVE_CONST_(T) \ 733735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typename ::testing::internal::RemoveConst<T>::type 734735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 735735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Turns const U&, U&, const U, and U all into U. 736735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ 737735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) 738735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 739735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Adds reference to a type if it is not a reference type, 740735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// otherwise leaves it unchanged. This is the same as 741735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// tr1::add_reference, which is not widely available yet. 742735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 743735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct AddReference { typedef T& type; }; // NOLINT 744735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 745735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct AddReference<T&> { typedef T& type; }; // NOLINT 746735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 747735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// A handy wrapper around AddReference that works when the argument T 748735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// depends on template parameters. 749735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_ADD_REFERENCE_(T) \ 750735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typename ::testing::internal::AddReference<T>::type 751735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 752735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Adds a reference to const on top of T as necessary. For example, 753735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// it transforms 754735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 755735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// char ==> const char& 756735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// const char ==> const char& 757735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// char& ==> const char& 758735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// const char& ==> const char& 759735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 760735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The argument T must depend on some template parameters. 761735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_REFERENCE_TO_CONST_(T) \ 762735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T)) 763735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 764735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// ImplicitlyConvertible<From, To>::value is a compile-time bool 765735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// constant that's true iff type From can be implicitly converted to 766735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// type To. 767735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename From, typename To> 768735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass ImplicitlyConvertible { 769735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 770735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // We need the following helper functions only for their types. 771735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // They have no implementations. 772735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 773735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // MakeFrom() is an expression whose type is From. We cannot simply 774735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // use From(), as the type From may not have a public default 775735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // constructor. 776735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static From MakeFrom(); 777735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 778735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // These two functions are overloaded. Given an expression 779735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Helper(x), the compiler will pick the first version if x can be 780735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // implicitly converted to type To; otherwise it will pick the 781735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // second version. 782735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 783735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // The first version returns a value of size 1, and the second 784735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // version returns a value of size 2. Therefore, by checking the 785735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // size of Helper(x), which can be done at compile time, we can tell 786735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // which version of Helper() is used, and hence whether x can be 787735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // implicitly converted to type To. 788735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static char Helper(To); 789735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static char (&Helper(...))[2]; // NOLINT 790735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 791735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // We have to put the 'public' section after the 'private' section, 792735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // or MSVC refuses to compile the code. 793735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 794735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // MSVC warns about implicitly converting from double to int for 795735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // possible loss of data, so we need to temporarily disable the 796735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // warning. 797735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#ifdef _MSC_VER 798735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# pragma warning(push) // Saves the current warning state. 799735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# pragma warning(disable:4244) // Temporarily disables warning 4244. 800735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 801735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const bool value = 802735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; 803735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner# pragma warning(pop) // Restores the warning state. 804735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#elif defined(__BORLANDC__) 805735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // C++Builder cannot use member overload resolution during template 806735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // instantiation. The simplest workaround is to use its C++0x type traits 807735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // functions (C++Builder 2009 and above only). 808735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const bool value = __is_convertible(From, To); 809735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#else 810735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static const bool value = 811735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; 812735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // _MSV_VER 813735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 814735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename From, typename To> 815735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerconst bool ImplicitlyConvertible<From, To>::value; 816735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 817735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// IsAProtocolMessage<T>::value is a compile-time bool constant that's 818735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// true iff T is type ProtocolMessage, proto2::Message, or a subclass 819735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// of those. 820735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T> 821735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerstruct IsAProtocolMessage 822735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner : public bool_constant< 823735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value || 824735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> { 825735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 826735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 827735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// When the compiler sees expression IsContainerTest<C>(0), if C is an 828735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// STL-style container class, the first overload of IsContainerTest 829735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// will be viable (since both C::iterator* and C::const_iterator* are 830735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// valid types and NULL can be implicitly converted to them). It will 831735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// be picked over the second overload as 'int' is a perfect match for 832735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the type of argument 0. If C::iterator or C::const_iterator is not 833735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// a valid type, the first overload is not viable, and the second 834735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// overload will be picked. Therefore, we can determine whether C is 835735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// a container class by checking the type of IsContainerTest<C>(0). 836735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The value of the expression is insignificant. 837735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 838735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Note that we look for both C::iterator and C::const_iterator. The 839735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// reason is that C++ injects the name of a class as a member of the 840735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// class itself (e.g. you can refer to class iterator as either 841735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 'iterator' or 'iterator::iterator'). If we look for C::iterator 842735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// only, for example, we would mistakenly think that a class named 843735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// iterator is an STL container. 844735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 845735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Also note that the simpler approach of overloading 846735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// IsContainerTest(typename C::const_iterator*) and 847735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. 848735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef int IsContainer; 849735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <class C> 850735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerIsContainer IsContainerTest(int /* dummy */, 851735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typename C::iterator* /* it */ = NULL, 852735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typename C::const_iterator* /* const_it */ = NULL) { 853735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return 0; 854735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 855735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 856735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertypedef char IsNotContainer; 857735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <class C> 858735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerIsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } 859735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 860735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// EnableIf<condition>::type is void when 'Cond' is true, and 861735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// undefined when 'Cond' is false. To use SFINAE to make a function 862735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// overload only apply when a particular expression is true, add 863735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// "typename EnableIf<expression>::type* = 0" as the last parameter. 864735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate<bool> struct EnableIf; 865735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate<> struct EnableIf<true> { typedef void type; }; // NOLINT 866735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 867735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Utilities for native arrays. 868735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 869735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// ArrayEq() compares two k-dimensional native arrays using the 870735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// elements' operator==, where k can be any integer >= 0. When k is 871735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// 0, ArrayEq() degenerates into comparing a single pair of values. 872735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 873735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U> 874735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerbool ArrayEq(const T* lhs, size_t size, const U* rhs); 875735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 876735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This generic version is used when k is 0. 877735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U> 878735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } 879735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 880735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This overload is used when k >= 1. 881735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U, size_t N> 882735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { 883735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return internal::ArrayEq(lhs, N, rhs); 884735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 885735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 886735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This helper reduces code bloat. If we instead put its logic inside 887735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the previous ArrayEq() function, arrays with different sizes would 888735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// lead to different copies of the template code. 889735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U> 890735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerbool ArrayEq(const T* lhs, size_t size, const U* rhs) { 891735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner for (size_t i = 0; i != size; i++) { 892735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (!internal::ArrayEq(lhs[i], rhs[i])) 893735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return false; 894735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 895735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return true; 896735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 897735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 898735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Finds the first element in the iterator range [begin, end) that 899735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// equals elem. Element may be a native array type itself. 900735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename Iter, typename Element> 901735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' TurnerIter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { 902735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner for (Iter it = begin; it != end; ++it) { 903735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (internal::ArrayEq(*it, elem)) 904735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return it; 905735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 906735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return end; 907735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 908735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 909735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// CopyArray() copies a k-dimensional native array using the elements' 910735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// operator=, where k can be any integer >= 0. When k is 0, 911735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// CopyArray() degenerates into copying a single value. 912735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 913735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U> 914735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnervoid CopyArray(const T* from, size_t size, U* to); 915735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 916735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This generic version is used when k is 0. 917735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U> 918735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline void CopyArray(const T& from, U* to) { *to = from; } 919735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 920735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This overload is used when k >= 1. 921735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U, size_t N> 922735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerinline void CopyArray(const T(&from)[N], U(*to)[N]) { 923735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner internal::CopyArray(from, N, *to); 924735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 925735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 926735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// This helper reduces code bloat. If we instead put its logic inside 927735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// the previous CopyArray() function, arrays with different sizes 928735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// would lead to different copies of the template code. 929735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename T, typename U> 930735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnervoid CopyArray(const T* from, size_t size, U* to) { 931735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner for (size_t i = 0; i != size; i++) { 932735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner internal::CopyArray(from[i], to + i); 933735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 934735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} 935735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 936735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// The relation between an NativeArray object (see below) and the 937735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// native array it represents. 938735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerenum RelationToSource { 939735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner kReference, // The NativeArray references the native array. 940735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner kCopy // The NativeArray makes a copy of the native array and 941735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // owns the copy. 942735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 943735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 944735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Adapts a native array to a read-only STL-style container. Instead 945735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// of the complete STL container concept, this adaptor only implements 946735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// members useful for Google Mock's container matchers. New members 947735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// should be added as needed. To simplify the implementation, we only 948735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// support Element being a raw type (i.e. having no top-level const or 949735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// reference modifier). It's the client's responsibility to satisfy 950735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// this requirement. Element can be an array type itself (hence 951735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// multi-dimensional arrays are supported). 952735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnertemplate <typename Element> 953735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass NativeArray { 954735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public: 955735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // STL-style container typedefs. 956735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef Element value_type; 957735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef Element* iterator; 958735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner typedef const Element* const_iterator; 959735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 960735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Constructs from a native array. 961735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner NativeArray(const Element* array, size_t count, RelationToSource relation) { 962735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Init(array, count, relation); 963735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 964735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 965735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Copy constructor. 966735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner NativeArray(const NativeArray& rhs) { 967735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Init(rhs.array_, rhs.size_, rhs.relation_to_source_); 968735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 969735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 970735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ~NativeArray() { 971735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Ensures that the user doesn't instantiate NativeArray with a 972735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // const or reference type. 973735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static_cast<void>(StaticAssertTypeEqHelper<Element, 974735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>()); 975735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (relation_to_source_ == kCopy) 976735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner delete[] array_; 977735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 978735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 979735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // STL-style container methods. 980735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner size_t size() const { return size_; } 981735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const_iterator begin() const { return array_; } 982735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const_iterator end() const { return array_ + size_; } 983735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool operator==(const NativeArray& rhs) const { 984735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return size() == rhs.size() && 985735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ArrayEq(begin(), size(), rhs.begin()); 986735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 987735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 988735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private: 989735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // Initializes this object; makes a copy of the input array if 990735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner // 'relation' is kCopy. 991735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner void Init(const Element* array, size_t a_size, RelationToSource relation) { 992735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (relation == kReference) { 993735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner array_ = array; 994735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } else { 995735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner Element* const copy = new Element[a_size]; 996735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner CopyArray(array, a_size, copy); 997735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner array_ = copy; 998735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 999735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner size_ = a_size; 1000735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner relation_to_source_ = relation; 1001735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } 1002735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1003735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner const Element* array_; 1004735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner size_t size_; 1005735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner RelationToSource relation_to_source_; 1006735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1007735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_DISALLOW_ASSIGN_(NativeArray); 1008735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner}; 1009735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1010735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} // namespace internal 1011735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner} // namespace testing 1012735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1013735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ 1014735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::testing::internal::AssertHelper(result_type, file, line, message) \ 1015735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner = ::testing::Message() 1016735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1017735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_MESSAGE_(message, result_type) \ 1018735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) 1019735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1020735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_FATAL_FAILURE_(message) \ 1021735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) 1022735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1023735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_NONFATAL_FAILURE_(message) \ 1024735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) 1025735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1026735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_SUCCESS_(message) \ 1027735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) 1028735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1029735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Suppresses MSVC warnings 4072 (unreachable code) for the code following 1030735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// statement if it returns or throws (or doesn't return or throw in some 1031735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// situations). 1032735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ 1033735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (::testing::internal::AlwaysTrue()) { statement; } 1034735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1035735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_THROW_(statement, expected_exception, fail) \ 1036735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1037735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (::testing::internal::ConstCharPtr gtest_msg = "") { \ 1038735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool gtest_caught_expected = false; \ 1039735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner try { \ 1040735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1041735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1042735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner catch (expected_exception const&) { \ 1043735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner gtest_caught_expected = true; \ 1044735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1045735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner catch (...) { \ 1046735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner gtest_msg.value = \ 1047735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner "Expected: " #statement " throws an exception of type " \ 1048735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner #expected_exception ".\n Actual: it throws a different type."; \ 1049735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ 1050735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1051735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (!gtest_caught_expected) { \ 1052735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner gtest_msg.value = \ 1053735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner "Expected: " #statement " throws an exception of type " \ 1054735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner #expected_exception ".\n Actual: it throws nothing."; \ 1055735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ 1056735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1057735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } else \ 1058735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \ 1059735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fail(gtest_msg.value) 1060735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1061735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_NO_THROW_(statement, fail) \ 1062735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1063735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (::testing::internal::AlwaysTrue()) { \ 1064735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner try { \ 1065735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1066735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1067735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner catch (...) { \ 1068735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ 1069735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1070735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } else \ 1071735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ 1072735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fail("Expected: " #statement " doesn't throw an exception.\n" \ 1073735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner " Actual: it throws.") 1074735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1075735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_ANY_THROW_(statement, fail) \ 1076735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1077735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (::testing::internal::AlwaysTrue()) { \ 1078735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner bool gtest_caught_any = false; \ 1079735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner try { \ 1080735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1081735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1082735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner catch (...) { \ 1083735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner gtest_caught_any = true; \ 1084735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1085735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (!gtest_caught_any) { \ 1086735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ 1087735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1088735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } else \ 1089735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ 1090735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fail("Expected: " #statement " throws an exception.\n" \ 1091735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner " Actual: it doesn't.") 1092735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1093735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1094735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Implements Boolean test assertions such as EXPECT_TRUE. expression can be 1095735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// either a boolean expression or an AssertionResult. text is a textual 1096735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// represenation of expression as it was passed into the EXPECT_TRUE. 1097735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ 1098735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1099735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (const ::testing::AssertionResult gtest_ar_ = \ 1100735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::testing::AssertionResult(expression)) \ 1101735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ; \ 1102735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner else \ 1103735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fail(::testing::internal::GetBoolAssertionFailureMessage(\ 1104735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner gtest_ar_, text, #actual, #expected).c_str()) 1105735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1106735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ 1107735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1108735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (::testing::internal::AlwaysTrue()) { \ 1109735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ 1110735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1111735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ 1112735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ 1113735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } \ 1114735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner } else \ 1115735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ 1116735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner fail("Expected: " #statement " doesn't generate new fatal " \ 1117735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner "failures in the current thread.\n" \ 1118735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner " Actual: it does.") 1119735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1120735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Expands to the name of the class that implements the given test. 1121735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ 1122735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner test_case_name##_##test_name##_Test 1123735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1124735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner// Helper macro for defining tests. 1125735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\ 1126735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnerclass GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\ 1127735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner public:\ 1128735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\ 1129735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner private:\ 1130735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner virtual void TestBody();\ 1131735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\ 1132735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_DISALLOW_COPY_AND_ASSIGN_(\ 1133735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ 1134735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner};\ 1135735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner\ 1136735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ 1137735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::test_info_ =\ 1138735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner ::testing::internal::MakeAndRegisterTestInfo(\ 1139735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner #test_case_name, #test_name, NULL, NULL, \ 1140735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner (parent_id), \ 1141735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner parent_class::SetUpTestCase, \ 1142735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner parent_class::TearDownTestCase, \ 1143735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner new ::testing::internal::TestFactoryImpl<\ 1144735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\ 1145735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turnervoid GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() 1146735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner 1147735d57d5d1c055db9e0ef28857e8dc7b3d7d6b9bDavid 'Digit' Turner#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 1148