1f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Copyright 2005, Google Inc. 2f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// All rights reserved. 3f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Redistribution and use in source and binary forms, with or without 5f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// modification, are permitted provided that the following conditions are 6f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// met: 7f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 8f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Redistributions of source code must retain the above copyright 9f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// notice, this list of conditions and the following disclaimer. 10f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Redistributions in binary form must reproduce the above 11f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// copyright notice, this list of conditions and the following disclaimer 12f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// in the documentation and/or other materials provided with the 13f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// distribution. 14f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Neither the name of Google Inc. nor the names of its 15f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// contributors may be used to endorse or promote products derived from 16f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// this software without specific prior written permission. 17f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 18f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 30f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) 31f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 32f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The Google C++ Testing Framework (Google Test) 33f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 34f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This header file declares functions and macros used internally by 35f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Google Test. They are subject to change without notice. 36f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 37f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 38f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 39f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 40f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/internal/gtest-port.h" 41f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 42f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_OS_LINUX 43f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <stdlib.h> 44f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <sys/types.h> 45f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <sys/wait.h> 46f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <unistd.h> 47f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_OS_LINUX 48f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 49f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_EXCEPTIONS 50f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <stdexcept> 51f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 52f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 53f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <ctype.h> 54f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <float.h> 55f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <string.h> 56f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <iomanip> 57f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <limits> 58f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <map> 59f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <set> 60f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <string> 61f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <vector> 62f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 63f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/gtest-message.h" 64f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/internal/gtest-string.h" 65f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/internal/gtest-filepath.h" 66f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/internal/gtest-type-util.h" 67f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 68f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Due to C++ preprocessor weirdness, we need double indirection to 69f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// concatenate two tokens when one of them is __LINE__. Writing 70f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 71f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// foo ## __LINE__ 72f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 73f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// will result in the token foo__LINE__, instead of foo followed by 74f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the current line number. For more details, see 75f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 76f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) 77f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar 78f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 79f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ProtocolMessage; 80f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace proto2 { class Message; } 81f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 82f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace testing { 83f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 84f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Forward declarations. 85f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 86f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass AssertionResult; // Result of an assertion. 87f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Message; // Represents a failure message. 88f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Test; // Represents a test. 89f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TestInfo; // Information about a test. 90f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TestPartResult; // Result of a test part. 91f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass UnitTest; // A collection of test cases. 92f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 93f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 94f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch::std::string PrintToString(const T& value); 95f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 96f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 97f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 98f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct TraceInfo; // Information about a trace point. 99f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ScopedTrace; // Implements scoped trace. 100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TestInfoImpl; // Opaque implementation of TestInfo 101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass UnitTestImpl; // Opaque implementation of UnitTest 102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The text used in failure messages to indicate the start of the 104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// stack trace. 105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ extern const char kStackTraceMarker[]; 106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Two overloaded helpers for checking at compile time whether an 108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// expression is a null pointer literal (i.e. NULL or any 0-valued 109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// compile-time integral constant). Their return values have 110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// different sizes, so we can use sizeof() to test which version is 111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// picked by the compiler. These helpers have no implementations, as 112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// we only need their signatures. 113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Given IsNullLiteralHelper(x), the compiler will pick the first 115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// version if x can be implicitly converted to Secret*, and pick the 116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second version otherwise. Since Secret is a secret and incomplete 117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type, the only expression a user can write that has type Secret* is 118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a null pointer literal. Therefore, we know that x is a null 119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// pointer literal if and only if the first version is picked by the 120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// compiler. 121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochchar IsNullLiteralHelper(Secret* p); 122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochchar (&IsNullLiteralHelper(...))[2]; // NOLINT 123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A compile-time bool constant that is true if and only if x is a 125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// null pointer literal (i.e. NULL or any 0-valued compile-time 126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// integral constant). 127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#ifdef GTEST_ELLIPSIS_NEEDS_POD_ 128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We lose support for NULL detection where the compiler doesn't like 129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// passing non-POD classes through ellipsis (...). 130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# define GTEST_IS_NULL_LITERAL_(x) false 131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else 132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# define GTEST_IS_NULL_LITERAL_(x) \ 133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) 134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_ELLIPSIS_NEEDS_POD_ 135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Appends the user-supplied message to the Google-Test-generated message. 137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::string AppendUserMessage( 138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::string& gtest_msg, const Message& user_msg); 139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_EXCEPTIONS 141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This exception is thrown by (and only by) a failed Google Test 143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions 144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// are enabled). We derive it from std::runtime_error, which is for 145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// errors presumably detectable only at run time. Since 146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// std::runtime_error inherits from std::exception, many testing 147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// frameworks know how to extract and print the message inside it. 148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ GoogleTestFailureException : public ::std::runtime_error { 149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit GoogleTestFailureException(const TestPartResult& failure); 151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_EXCEPTIONS 154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A helper class for creating scoped traces in user programs. 156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ ScopedTrace { 157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The c'tor pushes the given source file location and message onto 159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a trace stack maintained by Google Test. 160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ScopedTrace(const char* file, int line, const Message& message); 161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The d'tor pops the info pushed by the c'tor. 163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Note that the d'tor is not virtual in order to be efficient. 165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Don't inherit from ScopedTrace! 166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ~ScopedTrace(); 167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); 170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its 171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // c'tor and d'tor. Therefore it doesn't 172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // need to be used otherwise. 173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace edit_distance { 175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the optimal edits to go from 'left' to 'right'. 176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// All edits cost the same, with replace having lower priority than 177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// add/remove. 178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Simple implementation of the Wagner–Fischer algorithm. 179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm 180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochenum EditType { kMatch, kAdd, kRemove, kReplace }; 181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::vector<EditType> CalculateOptimalEdits( 182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::vector<size_t>& left, const std::vector<size_t>& right); 183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Same as above, but the input is represented as strings. 185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::vector<EditType> CalculateOptimalEdits( 186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::vector<std::string>& left, 187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::vector<std::string>& right); 188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Create a diff of the input strings in Unified diff format. 190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left, 191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::vector<std::string>& right, 192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t context = 2); 193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace edit_distance 195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Calculate the diff between 'left' and 'right' and return it in unified diff 197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// format. 198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If not null, stores in 'total_line_count' the total number of lines found 199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// in left + right. 200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::string DiffStrings(const std::string& left, 201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::string& right, 202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t* total_line_count); 203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Constructs and returns the message for an equality assertion 205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. 206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The first four parameters are the expressions used in the assertion 208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and their values, as strings. For example, for ASSERT_EQ(foo, bar) 209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// where foo is 5 and bar is 6, we have: 210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// expected_expression: "foo" 212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// actual_expression: "bar" 213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// expected_value: "5" 214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// actual_value: "6" 215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The ignoring_case parameter is true iff the assertion is a 217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will 218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// be inserted into the message. 219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ AssertionResult EqFailure(const char* expected_expression, 220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* actual_expression, 221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::string& expected_value, 222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const std::string& actual_value, 223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool ignoring_case); 224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. 226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::string GetBoolAssertionFailureMessage( 227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const AssertionResult& assertion_result, 228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* expression_text, 229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* actual_predicate_value, 230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* expected_predicate_value); 231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This template class represents an IEEE floating-point number 233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (either single-precision or double-precision, depending on the 234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// template parameters). 235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The purpose of this class is to do more sophisticated number 237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// comparison. (Due to round-off error, etc, it's very unlikely that 238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// two floating-points will be equal exactly. Hence a naive 239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// comparison by the == operation often doesn't work.) 240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Format of IEEE floating-point: 242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The most-significant bit being the leftmost, an IEEE 244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// floating-point looks like 245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// sign_bit exponent_bits fraction_bits 247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Here, sign_bit is a single bit that designates the sign of the 249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// number. 250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For float, there are 8 exponent bits and 23 fraction bits. 252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For double, there are 11 exponent bits and 52 fraction bits. 254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// More details can be found at 256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// http://en.wikipedia.org/wiki/IEEE_floating-point_standard. 257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Template parameter: 259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// RawType: the raw floating-point type (either float or double) 261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename RawType> 262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass FloatingPoint { 263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Defines the unsigned integer type that has the same size as the 265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // floating point number. 266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits; 267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constants. 269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // # of bits in a number. 271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const size_t kBitCount = 8*sizeof(RawType); 272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // # of fraction bits in a number. 274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const size_t kFractionBitCount = 275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::numeric_limits<RawType>::digits - 1; 276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // # of exponent bits in a number. 278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; 279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The mask for the sign bit. 281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1); 282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The mask for the fraction bits. 284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const Bits kFractionBitMask = 285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ~static_cast<Bits>(0) >> (kExponentBitCount + 1); 286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The mask for the exponent bits. 288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); 289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // How many ULP's (Units in the Last Place) we want to tolerate when 291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // comparing two numbers. The larger the value, the more error we 292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // allow. A 0 value means that two numbers must be exactly the same 293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to be considered equal. 294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The maximum error of a single floating-point operation is 0.5 296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // units in the last place. On Intel CPU's, all floating-point 297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // calculations are done with 80-bit precision, while double has 64 298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // bits. Therefore, 4 should be enough for ordinary use. 299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // See the following article for more details on ULP: 301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ 302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const size_t kMaxUlps = 4; 303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs a FloatingPoint from a raw floating-point number. 305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // On an Intel CPU, passing a non-normalized NAN (Not a Number) 307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // around may change its bits, although the new value is guaranteed 308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to be also a NAN. Therefore, don't expect this constructor to 309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // preserve the bits in x when x is a NAN. 310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit FloatingPoint(const RawType& x) { u_.value_ = x; } 311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Static methods 313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Reinterprets a bit pattern as a floating-point number. 315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This function is needed to test the AlmostEquals() method. 317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static RawType ReinterpretBits(const Bits bits) { 318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FloatingPoint fp(0); 319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fp.u_.bits_ = bits; 320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return fp.u_.value_; 321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the floating-point number that represent positive infinity. 324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static RawType Infinity() { 325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ReinterpretBits(kExponentBitMask); 326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the maximum representable finite floating-point number. 329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static RawType Max(); 330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Non-static methods 332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the bits that represents this number. 334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits &bits() const { return u_.bits_; } 335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the exponent bits of this number. 337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } 338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the fraction bits of this number. 340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } 341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the sign bit of this number. 343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Bits sign_bit() const { return kSignBitMask & u_.bits_; } 344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff this is NAN (not a number). 346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool is_nan() const { 347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // It's a NAN if the exponent bits are all ones and the fraction 348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // bits are not entirely zeros. 349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); 350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff this number is at most kMaxUlps ULP's away from 353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // rhs. In particular, this function: 354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // - returns false if either number is (or both are) NAN. 356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // - treats really large numbers as almost equal to infinity. 357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // - thinks +0.0 and -0.0 are 0 DLP's apart. 358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool AlmostEquals(const FloatingPoint& rhs) const { 359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The IEEE standard says that any comparison operation involving 360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a NAN must return false. 361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (is_nan() || rhs.is_nan()) return false; 362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) 364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch <= kMaxUlps; 365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The data type used to store the actual floating-point number. 369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch union FloatingPointUnion { 370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RawType value_; // The raw floating-point number. 371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Bits bits_; // The bits that represent the number. 372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Converts an integer from the sign-and-magnitude representation to 375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the biased representation. More precisely, let N be 2 to the 376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // power of (kBitCount - 1), an integer x is represented by the 377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // unsigned number x + N. 378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // For instance, 380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // -N + 1 (the most negative number representable using 382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // sign-and-magnitude) is represented by 1; 383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 0 is represented by N; and 384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // N - 1 (the biggest number representable using 385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // sign-and-magnitude) is represented by 2N - 1. 386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Read http://en.wikipedia.org/wiki/Signed_number_representations 388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // for more details on signed number representations. 389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Bits SignAndMagnitudeToBiased(const Bits &sam) { 390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (kSignBitMask & sam) { 391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // sam represents a negative number. 392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ~sam + 1; 393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // sam represents a positive number. 395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return kSignBitMask | sam; 396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Given two numbers in the sign-and-magnitude representation, 400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // returns the distance between them as an unsigned number. 401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, 402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits &sam2) { 403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits biased1 = SignAndMagnitudeToBiased(sam1); 404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits biased2 = SignAndMagnitudeToBiased(sam2); 405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); 406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FloatingPointUnion u_; 409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We cannot use std::numeric_limits<T>::max() as it clashes with the max() 412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// macro defined by <windows.h>. 413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline float FloatingPoint<float>::Max() { return FLT_MAX; } 415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline double FloatingPoint<double>::Max() { return DBL_MAX; } 417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Typedefs the instances of the FloatingPoint template class that we 419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// care to use. 420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef FloatingPoint<float> Float; 421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef FloatingPoint<double> Double; 422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// In order to catch the mistake of putting tests that use different 424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// test fixture classes in the same test case, we need to assign 425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// unique IDs to fixture classes and compare them. The TypeId type is 426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// used to hold such IDs. The user should treat TypeId as an opaque 427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type: the only operation allowed on TypeId values is to compare 428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// them for equality using the == operator. 429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef const void* TypeId; 430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TypeIdHelper { 433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // dummy_ must not have a const type. Otherwise an overly eager 435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // compiler (e.g. MSVC 7.1 & 8.0) may try to merge 436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // TypeIdHelper<T>::dummy_ for different Ts as an "optimization". 437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool dummy_; 438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool TypeIdHelper<T>::dummy_ = false; 442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// GetTypeId<T>() returns the ID of type T. Different values will be 444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returned for different types. Calling the function twice with the 445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// same type argument is guaranteed to return the same ID. 446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTypeId GetTypeId() { 448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The compiler is required to allocate a different 449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // TypeIdHelper<T>::dummy_ variable for each T used to instantiate 450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the template. Therefore, the address of dummy_ is guaranteed to 451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // be unique. 452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return &(TypeIdHelper<T>::dummy_); 453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the type ID of ::testing::Test. Always call this instead 456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of GetTypeId< ::testing::Test>() to get the type ID of 457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ::testing::Test, as the latter may give the wrong result due to a 458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// suspected linker bug when compiling Google Test as a Mac OS X 459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// framework. 460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ TypeId GetTestTypeId(); 461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Defines the abstract factory interface that creates instances 463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of a Test object. 464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TestFactoryBase { 465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual ~TestFactoryBase() {} 467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Creates a test instance to run. The instance is both created and destroyed 469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // within TestInfoImpl::Run() 470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual Test* CreateTest() = 0; 471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestFactoryBase() {} 474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); 477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This class provides implementation of TeastFactoryBase interface. 480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// It is used in TEST and TEST_F macros. 481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <class TestClass> 482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TestFactoryImpl : public TestFactoryBase { 483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual Test* CreateTest() { return new TestClass; } 485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_OS_WINDOWS 488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Predicate-formatters for implementing the HRESULT checking macros 490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} 491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We pass a long instead of HRESULT to avoid causing an 492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// include dependency for the HRESULT type. 493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, 494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch long hr); // NOLINT 495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, 496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch long hr); // NOLINT 497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_OS_WINDOWS 499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Types of SetUpTestCase() and TearDownTestCase() functions. 501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef void (*SetUpTestCaseFunc)(); 502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef void (*TearDownTestCaseFunc)(); 503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct CodeLocation { 505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CodeLocation(const string& a_file, int a_line) : file(a_file), line(a_line) {} 506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string file; 508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int line; 509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a new TestInfo object and registers it with Google Test; 512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns the created object. 513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Arguments: 515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// test_case_name: name of the test case 517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// name: name of the test 518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type_param the name of the test's type parameter, or NULL if 519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// this is not a typed or a type-parameterized test. 520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// value_param text representation of the test's value parameter, 521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// or NULL if this is not a type-parameterized test. 522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// code_location: code location where the test is defined 523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// fixture_class_id: ID of the test fixture class 524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// set_up_tc: pointer to the function that sets up the test case 525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// tear_down_tc: pointer to the function that tears down the test case 526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// factory: pointer to the factory that creates a test object. 527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The newly created TestInfo instance will assume 528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ownership of the factory object. 529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ TestInfo* MakeAndRegisterTestInfo( 530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* test_case_name, 531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* name, 532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* type_param, 533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* value_param, 534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CodeLocation code_location, 535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeId fixture_class_id, 536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SetUpTestCaseFunc set_up_tc, 537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TearDownTestCaseFunc tear_down_tc, 538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestFactoryBase* factory); 539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If *pstr starts with the given prefix, modifies *pstr to be right 541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// past the prefix and returns true; otherwise leaves *pstr unchanged 542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and returns false. None of pstr, *pstr, and prefix can be NULL. 543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); 544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P 546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// State of the definition of a type-parameterized test case. 548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ TypedTestCasePState { 549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypedTestCasePState() : registered_(false) {} 551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Adds the given test name to defined_test_names_ and return true 553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // if the test case hasn't been registered; otherwise aborts the 554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // program. 555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool AddTestName(const char* file, int line, const char* case_name, 556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* test_name) { 557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (registered_) { 558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fprintf(stderr, "%s Test %s must be defined before " 559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n", 560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FormatFileLocation(file, line).c_str(), test_name, case_name); 561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fflush(stderr); 562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch posix::Abort(); 563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch registered_tests_.insert( 565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::make_pair(test_name, CodeLocation(file, line))); 566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool TestExists(const std::string& test_name) const { 570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return registered_tests_.count(test_name) > 0; 571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const CodeLocation& GetCodeLocation(const std::string& test_name) const { 574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name); 575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CHECK_(it != registered_tests_.end()); 576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return it->second; 577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verifies that registered_tests match the test names in 580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // defined_test_names_; returns registered_tests if successful, or 581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // aborts the program otherwise. 582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* VerifyRegisteredTestNames( 583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* file, int line, const char* registered_tests); 584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap; 587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool registered_; 589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RegisteredTestsMap registered_tests_; 590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Skips to the first non-space char after the first comma in 'str'; 593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns NULL if no comma is found in 'str'. 594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline const char* SkipComma(const char* str) { 595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* comma = strchr(str, ','); 596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (comma == NULL) { 597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return NULL; 598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch while (IsSpace(*(++comma))) {} 600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return comma; 601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the prefix of 'str' before the first comma in it; returns 604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the entire string if it contains no comma. 605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline std::string GetPrefixUntilComma(const char* str) { 606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* comma = strchr(str, ','); 607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return comma == NULL ? str : std::string(str, comma); 608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Splits a given string on a given delimiter, populating a given 611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// vector with the fields. 612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid SplitString(const ::std::string& str, char delimiter, 613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector< ::std::string>* dest); 614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TypeParameterizedTest<Fixture, TestSel, Types>::Register() 616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// registers a list of type-parameterized tests with Google Test. The 617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// return value is insignificant - we just need to return something 618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// such that we can call this function in a namespace scope. 619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implementation note: The GTEST_TEMPLATE_ macro declares a template 621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// template parameter. It's defined in gtest-type-util.h. 622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types> 623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TypeParameterizedTest { 624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 'index' is the index of the test in the type list 'Types' 626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase, 627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Types). Valid values for 'index' are [0, N - 1] where N is the 628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // length of Types. 629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool Register(const char* prefix, 630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CodeLocation code_location, 631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* case_name, const char* test_names, 632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int index) { 633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename Types::Head Type; 634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef Fixture<Type> FixtureClass; 635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename GTEST_BIND_(TestSel, Type) TestClass; 636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // First, registers the first type-parameterized test in the type 638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // list. 639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MakeAndRegisterTestInfo( 640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/" 641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch + StreamableToString(index)).c_str(), 642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(), 643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GetTypeName<Type>().c_str(), 644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch NULL, // No value parameter. 645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch code_location, 646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GetTypeId<FixtureClass>(), 647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestClass::SetUpTestCase, 648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestClass::TearDownTestCase, 649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new TestFactoryImpl<TestClass>); 650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Next, recurses (at compile time) with the tail of the type list. 652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail> 653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::Register(prefix, code_location, case_name, test_names, index + 1); 654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The base case for the compile time recursion. 658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <GTEST_TEMPLATE_ Fixture, class TestSel> 659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TypeParameterizedTest<Fixture, TestSel, Types0> { 660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool Register(const char* /*prefix*/, CodeLocation, 662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* /*case_name*/, const char* /*test_names*/, 663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int /*index*/) { 664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TypeParameterizedTestCase<Fixture, Tests, Types>::Register() 669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// registers *all combinations* of 'Tests' and 'Types' with Google 670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Test. The return value is insignificant - we just need to return 671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// something such that we can call this function in a namespace scope. 672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types> 673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TypeParameterizedTestCase { 674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool Register(const char* prefix, CodeLocation code_location, 676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const TypedTestCasePState* state, 677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* case_name, const char* test_names) { 678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string test_name = StripTrailingSpaces( 679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GetPrefixUntilComma(test_names)); 680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!state->TestExists(test_name)) { 681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fprintf(stderr, "Failed to get code location for test %s.%s at %s.", 682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch case_name, test_name.c_str(), 683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FormatFileLocation(code_location.file.c_str(), 684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch code_location.line).c_str()); 685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fflush(stderr); 686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch posix::Abort(); 687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const CodeLocation& test_location = state->GetCodeLocation(test_name); 689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename Tests::Head Head; 691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // First, register the first test in 'Test' for each type in 'Types'. 693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParameterizedTest<Fixture, Head, Types>::Register( 694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch prefix, test_location, case_name, test_names, 0); 695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Next, recurses (at compile time) with the tail of the test list. 697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types> 698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::Register(prefix, code_location, state, 699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch case_name, SkipComma(test_names)); 700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The base case for the compile time recursion. 704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <GTEST_TEMPLATE_ Fixture, typename Types> 705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TypeParameterizedTestCase<Fixture, Templates0, Types> { 706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool Register(const char* /*prefix*/, CodeLocation, 708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const TypedTestCasePState* /*state*/, 709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* /*case_name*/, const char* /*test_names*/) { 710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P 715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the current OS stack trace as an std::string. 717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The maximum number of stack frames to be included is specified by 719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the gtest_stack_trace_depth flag. The skip_count parameter 720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// specifies the number of top frames to be skipped, which doesn't 721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// count against the number of frames to be included. 722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For example, if Foo() calls Bar(), which in turn calls 724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in 725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. 726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ std::string GetCurrentOsStackTraceExceptTop( 727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UnitTest* unit_test, int skip_count); 728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Helpers for suppressing warnings on unreachable code or constant 730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// condition. 731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Always returns true. 733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ bool AlwaysTrue(); 734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Always returns false. 736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool AlwaysFalse() { return !AlwaysTrue(); } 737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Helper for suppressing false warning from Clang on a const char* 739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// variable declared in a conditional expression always being NULL in 740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the else branch. 741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct GTEST_API_ ConstCharPtr { 742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConstCharPtr(const char* str) : value(str) {} 743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator bool() const { return true; } 744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* value; 745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A simple Linear Congruential Generator for generating random 748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// numbers with a uniform distribution. Unlike rand() and srand(), it 749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// doesn't use global state (and therefore can't interfere with user 750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// code). Unlike rand_r(), it's portable. An LCG isn't very random, 751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// but it's good enough for our purposes. 752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ Random { 753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const UInt32 kMaxRange = 1u << 31; 755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Random(UInt32 seed) : state_(seed) {} 757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void Reseed(UInt32 seed) { state_ = seed; } 759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Generates a random number from [0, range). Crashes if 'range' is 761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 0 or greater than kMaxRange. 762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UInt32 Generate(UInt32 range); 763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UInt32 state_; 766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); 767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a 770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// compiler error iff T1 and T2 are different types. 771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T1, typename T2> 772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct CompileAssertTypesEqual; 773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct CompileAssertTypesEqual<T, T> { 776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Removes the reference from a type if it is a reference type, 779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// otherwise leaves it unchanged. This is the same as 780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// tr1::remove_reference, which is not widely available yet. 781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RemoveReference { typedef T type; }; // NOLINT 783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RemoveReference<T&> { typedef T type; }; // NOLINT 785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A handy wrapper around RemoveReference that works when the argument 787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T depends on template parameters. 788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_REMOVE_REFERENCE_(T) \ 789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::testing::internal::RemoveReference<T>::type 790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Removes const from a type if it is a const type, otherwise leaves 792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// it unchanged. This is the same as tr1::remove_const, which is not 793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// widely available yet. 794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RemoveConst { typedef T type; }; // NOLINT 796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RemoveConst<const T> { typedef T type; }; // NOLINT 798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above 800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// definition to fail to remove the const in 'const int[3]' and 'const 801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// char[3][4]'. The following specialization works around the bug. 802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, size_t N> 803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RemoveConst<const T[N]> { 804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RemoveConst<T>::type type[N]; 805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if defined(_MSC_VER) && _MSC_VER < 1400 808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This is the only specialization that allows VC++ 7.1 to remove const in 809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'const int[3] and 'const int[3][4]'. However, it causes trouble with GCC 810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and thus needs to be conditionally compiled. 811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, size_t N> 812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RemoveConst<T[N]> { 813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RemoveConst<T>::type type[N]; 814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A handy wrapper around RemoveConst that works when the argument 818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T depends on template parameters. 819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_REMOVE_CONST_(T) \ 820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::testing::internal::RemoveConst<T>::type 821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Turns const U&, U&, const U, and U all into U. 823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ 824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) 825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Adds reference to a type if it is not a reference type, 827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// otherwise leaves it unchanged. This is the same as 828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// tr1::add_reference, which is not widely available yet. 829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AddReference { typedef T& type; }; // NOLINT 831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AddReference<T&> { typedef T& type; }; // NOLINT 833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A handy wrapper around AddReference that works when the argument T 835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// depends on template parameters. 836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_ADD_REFERENCE_(T) \ 837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::testing::internal::AddReference<T>::type 838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Adds a reference to const on top of T as necessary. For example, 840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// it transforms 841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// char ==> const char& 843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// const char ==> const char& 844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// char& ==> const char& 845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// const char& ==> const char& 846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The argument T must depend on some template parameters. 848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_REFERENCE_TO_CONST_(T) \ 849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T)) 850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ImplicitlyConvertible<From, To>::value is a compile-time bool 852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// constant that's true iff type From can be implicitly converted to 853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type To. 854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename From, typename To> 855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ImplicitlyConvertible { 856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We need the following helper functions only for their types. 858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // They have no implementations. 859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MakeFrom() is an expression whose type is From. We cannot simply 861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // use From(), as the type From may not have a public default 862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // constructor. 863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static typename AddReference<From>::type MakeFrom(); 864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // These two functions are overloaded. Given an expression 866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Helper(x), the compiler will pick the first version if x can be 867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implicitly converted to type To; otherwise it will pick the 868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // second version. 869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The first version returns a value of size 1, and the second 871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // version returns a value of size 2. Therefore, by checking the 872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // size of Helper(x), which can be done at compile time, we can tell 873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which version of Helper() is used, and hence whether x can be 874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implicitly converted to type To. 875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static char Helper(To); 876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static char (&Helper(...))[2]; // NOLINT 877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We have to put the 'public' section after the 'private' section, 879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // or MSVC refuses to compile the code. 880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if defined(__BORLANDC__) 882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // C++Builder cannot use member overload resolution during template 883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // instantiation. The simplest workaround is to use its C++0x type traits 884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // functions (C++Builder 2009 and above only). 885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const bool value = __is_convertible(From, To); 886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else 887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MSVC warns about implicitly converting from double to int for 888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // possible loss of data, so we need to temporarily disable the 889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // warning. 890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244) 891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const bool value = 892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; 893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISABLE_MSC_WARNINGS_POP_() 894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // __BORLANDC__ 895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename From, typename To> 897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst bool ImplicitlyConvertible<From, To>::value; 898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// IsAProtocolMessage<T>::value is a compile-time bool constant that's 900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// true iff T is type ProtocolMessage, proto2::Message, or a subclass 901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of those. 902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct IsAProtocolMessage 904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public bool_constant< 905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value || 906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> { 907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// When the compiler sees expression IsContainerTest<C>(0), if C is an 910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// STL-style container class, the first overload of IsContainerTest 911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// will be viable (since both C::iterator* and C::const_iterator* are 912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// valid types and NULL can be implicitly converted to them). It will 913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// be picked over the second overload as 'int' is a perfect match for 914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the type of argument 0. If C::iterator or C::const_iterator is not 915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a valid type, the first overload is not viable, and the second 916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// overload will be picked. Therefore, we can determine whether C is 917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a container class by checking the type of IsContainerTest<C>(0). 918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The value of the expression is insignificant. 919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Note that we look for both C::iterator and C::const_iterator. The 921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// reason is that C++ injects the name of a class as a member of the 922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// class itself (e.g. you can refer to class iterator as either 923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'iterator' or 'iterator::iterator'). If we look for C::iterator 924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// only, for example, we would mistakenly think that a class named 925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// iterator is an STL container. 926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Also note that the simpler approach of overloading 928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// IsContainerTest(typename C::const_iterator*) and 929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. 930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef int IsContainer; 931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <class C> 932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochIsContainer IsContainerTest(int /* dummy */, 933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename C::iterator* /* it */ = NULL, 934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename C::const_iterator* /* const_it */ = NULL) { 935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return 0; 936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef char IsNotContainer; 939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <class C> 940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochIsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } 941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EnableIf<condition>::type is void when 'Cond' is true, and 943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// undefined when 'Cond' is false. To use SFINAE to make a function 944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// overload only apply when a particular expression is true, add 945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "typename EnableIf<expression>::type* = 0" as the last parameter. 946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate<bool> struct EnableIf; 947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate<> struct EnableIf<true> { typedef void type; }; // NOLINT 948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Utilities for native arrays. 950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ArrayEq() compares two k-dimensional native arrays using the 952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// elements' operator==, where k can be any integer >= 0. When k is 953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 0, ArrayEq() degenerates into comparing a single pair of values. 954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool ArrayEq(const T* lhs, size_t size, const U* rhs); 957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This generic version is used when k is 0. 959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } 961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This overload is used when k >= 1. 963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U, size_t N> 964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { 965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::ArrayEq(lhs, N, rhs); 966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This helper reduces code bloat. If we instead put its logic inside 969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the previous ArrayEq() function, arrays with different sizes would 970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// lead to different copies of the template code. 971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool ArrayEq(const T* lhs, size_t size, const U* rhs) { 973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i != size; i++) { 974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!internal::ArrayEq(lhs[i], rhs[i])) 975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Finds the first element in the iterator range [begin, end) that 981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// equals elem. Element may be a native array type itself. 982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Iter, typename Element> 983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochIter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { 984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (Iter it = begin; it != end; ++it) { 985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (internal::ArrayEq(*it, elem)) 986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return it; 987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return end; 989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// CopyArray() copies a k-dimensional native array using the elements' 992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// operator=, where k can be any integer >= 0. When k is 0, 993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// CopyArray() degenerates into copying a single value. 994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid CopyArray(const T* from, size_t size, U* to); 997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This generic version is used when k is 0. 999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 1000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline void CopyArray(const T& from, U* to) { *to = from; } 1001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This overload is used when k >= 1. 1003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U, size_t N> 1004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline void CopyArray(const T(&from)[N], U(*to)[N]) { 1005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::CopyArray(from, N, *to); 1006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This helper reduces code bloat. If we instead put its logic inside 1009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the previous CopyArray() function, arrays with different sizes 1010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// would lead to different copies of the template code. 1011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 1012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid CopyArray(const T* from, size_t size, U* to) { 1013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i != size; i++) { 1014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::CopyArray(from[i], to + i); 1015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The relation between an NativeArray object (see below) and the 1019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// native array it represents. 1020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We use 2 different structs to allow non-copyable types to be used, as long 1021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// as RelationToSourceReference() is passed. 1022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RelationToSourceReference {}; 1023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct RelationToSourceCopy {}; 1024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Adapts a native array to a read-only STL-style container. Instead 1026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of the complete STL container concept, this adaptor only implements 1027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// members useful for Google Mock's container matchers. New members 1028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// should be added as needed. To simplify the implementation, we only 1029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// support Element being a raw type (i.e. having no top-level const or 1030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// reference modifier). It's the client's responsibility to satisfy 1031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// this requirement. Element can be an array type itself (hence 1032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// multi-dimensional arrays are supported). 1033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Element> 1034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NativeArray { 1035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // STL-style container typedefs. 1037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef Element value_type; 1038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef Element* iterator; 1039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef const Element* const_iterator; 1040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs from a native array. References the source. 1042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch NativeArray(const Element* array, size_t count, RelationToSourceReference) { 1043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch InitRef(array, count); 1044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs from a native array. Copies the source. 1047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch NativeArray(const Element* array, size_t count, RelationToSourceCopy) { 1048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch InitCopy(array, count); 1049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Copy constructor. 1052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch NativeArray(const NativeArray& rhs) { 1053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (this->*rhs.clone_)(rhs.array_, rhs.size_); 1054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ~NativeArray() { 1057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (clone_ != &NativeArray::InitRef) 1058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch delete[] array_; 1059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // STL-style container methods. 1062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t size() const { return size_; } 1063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const_iterator begin() const { return array_; } 1064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const_iterator end() const { return array_ + size_; } 1065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator==(const NativeArray& rhs) const { 1066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return size() == rhs.size() && 1067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ArrayEq(begin(), size(), rhs.begin()); 1068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch enum { 1072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper< 1073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value, 1074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 1075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Initializes this object with a copy of the input. 1077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void InitCopy(const Element* array, size_t a_size) { 1078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Element* const copy = new Element[a_size]; 1079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CopyArray(array, a_size, copy); 1080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch array_ = copy; 1081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_ = a_size; 1082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch clone_ = &NativeArray::InitCopy; 1083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Initializes this object with a reference of the input. 1086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void InitRef(const Element* array, size_t a_size) { 1087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch array_ = array; 1088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_ = a_size; 1089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch clone_ = &NativeArray::InitRef; 1090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Element* array_; 1093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t size_; 1094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void (NativeArray::*clone_)(const Element*, size_t); 1095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(NativeArray); 1097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 1100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace testing 1101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ 1103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::AssertHelper(result_type, file, line, message) \ 1104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch = ::testing::Message() 1105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_MESSAGE_(message, result_type) \ 1107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) 1108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_FATAL_FAILURE_(message) \ 1110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) 1111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_NONFATAL_FAILURE_(message) \ 1113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) 1114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_SUCCESS_(message) \ 1116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) 1117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Suppresses MSVC warnings 4072 (unreachable code) for the code following 1119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// statement if it returns or throws (or doesn't return or throw in some 1120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// situations). 1121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ 1122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (::testing::internal::AlwaysTrue()) { statement; } 1123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_THROW_(statement, expected_exception, fail) \ 1125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (::testing::internal::ConstCharPtr gtest_msg = "") { \ 1127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool gtest_caught_expected = false; \ 1128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch try { \ 1129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch catch (expected_exception const&) { \ 1132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch gtest_caught_expected = true; \ 1133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch catch (...) { \ 1135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch gtest_msg.value = \ 1136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: " #statement " throws an exception of type " \ 1137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch #expected_exception ".\n Actual: it throws a different type."; \ 1138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ 1139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!gtest_caught_expected) { \ 1141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch gtest_msg.value = \ 1142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: " #statement " throws an exception of type " \ 1143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch #expected_exception ".\n Actual: it throws nothing."; \ 1144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ 1145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else \ 1147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \ 1148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fail(gtest_msg.value) 1149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_NO_THROW_(statement, fail) \ 1151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (::testing::internal::AlwaysTrue()) { \ 1153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch try { \ 1154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch catch (...) { \ 1157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ 1158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else \ 1160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ 1161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fail("Expected: " #statement " doesn't throw an exception.\n" \ 1162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: it throws.") 1163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_ANY_THROW_(statement, fail) \ 1165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (::testing::internal::AlwaysTrue()) { \ 1167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool gtest_caught_any = false; \ 1168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch try { \ 1169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch catch (...) { \ 1172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch gtest_caught_any = true; \ 1173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!gtest_caught_any) { \ 1175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ 1176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else \ 1178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ 1179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fail("Expected: " #statement " throws an exception.\n" \ 1180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: it doesn't.") 1181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements Boolean test assertions such as EXPECT_TRUE. expression can be 1184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// either a boolean expression or an AssertionResult. text is a textual 1185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// represenation of expression as it was passed into the EXPECT_TRUE. 1186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ 1187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (const ::testing::AssertionResult gtest_ar_ = \ 1189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::AssertionResult(expression)) \ 1190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ; \ 1191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else \ 1192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fail(::testing::internal::GetBoolAssertionFailureMessage(\ 1193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch gtest_ar_, text, #actual, #expected).c_str()) 1194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ 1196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (::testing::internal::AlwaysTrue()) { \ 1198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ 1199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 1200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ 1201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ 1202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } \ 1203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else \ 1204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ 1205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch fail("Expected: " #statement " doesn't generate new fatal " \ 1206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "failures in the current thread.\n" \ 1207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: it does.") 1208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Expands to the name of the class that implements the given test. 1210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ 1211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch test_case_name##_##test_name##_Test 1212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Helper macro for defining tests. 1214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\ 1215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\ 1216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public:\ 1217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\ 1218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private:\ 1219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void TestBody();\ 1220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\ 1221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(\ 1222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ 1223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch};\ 1224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch\ 1225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ 1226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::test_info_ =\ 1227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::MakeAndRegisterTestInfo(\ 1228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch #test_case_name, #test_name, NULL, NULL, \ 1229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::CodeLocation(__FILE__, __LINE__), \ 1230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (parent_id), \ 1231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch parent_class::SetUpTestCase, \ 1232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch parent_class::TearDownTestCase, \ 1233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new ::testing::internal::TestFactoryImpl<\ 1234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\ 1235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() 1236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 1238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1239