113481Sgiacomo.travaglini@arm.com// Copyright 2005, Google Inc. 213481Sgiacomo.travaglini@arm.com// All rights reserved. 313481Sgiacomo.travaglini@arm.com// 413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without 513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are 613481Sgiacomo.travaglini@arm.com// met: 713481Sgiacomo.travaglini@arm.com// 813481Sgiacomo.travaglini@arm.com// * Redistributions of source code must retain the above copyright 913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer. 1013481Sgiacomo.travaglini@arm.com// * Redistributions in binary form must reproduce the above 1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer 1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the 1313481Sgiacomo.travaglini@arm.com// distribution. 1413481Sgiacomo.travaglini@arm.com// * Neither the name of Google Inc. nor the names of its 1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from 1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission. 1713481Sgiacomo.travaglini@arm.com// 1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2913481Sgiacomo.travaglini@arm.com// 3013481Sgiacomo.travaglini@arm.com// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) 3113481Sgiacomo.travaglini@arm.com// 3213481Sgiacomo.travaglini@arm.com// The Google C++ Testing Framework (Google Test) 3313481Sgiacomo.travaglini@arm.com// 3413481Sgiacomo.travaglini@arm.com// This header file declares functions and macros used internally by 3513481Sgiacomo.travaglini@arm.com// Google Test. They are subject to change without notice. 3613481Sgiacomo.travaglini@arm.com 3713481Sgiacomo.travaglini@arm.com#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 3813481Sgiacomo.travaglini@arm.com#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 3913481Sgiacomo.travaglini@arm.com 4013481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-port.h" 4113481Sgiacomo.travaglini@arm.com 4213481Sgiacomo.travaglini@arm.com#if GTEST_OS_LINUX 4313481Sgiacomo.travaglini@arm.com# include <stdlib.h> 4413481Sgiacomo.travaglini@arm.com# include <sys/types.h> 4513481Sgiacomo.travaglini@arm.com# include <sys/wait.h> 4613481Sgiacomo.travaglini@arm.com# include <unistd.h> 4713481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_LINUX 4813481Sgiacomo.travaglini@arm.com 4913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 5013481Sgiacomo.travaglini@arm.com# include <stdexcept> 5113481Sgiacomo.travaglini@arm.com#endif 5213481Sgiacomo.travaglini@arm.com 5313481Sgiacomo.travaglini@arm.com#include <ctype.h> 5413481Sgiacomo.travaglini@arm.com#include <float.h> 5513481Sgiacomo.travaglini@arm.com#include <string.h> 5613481Sgiacomo.travaglini@arm.com#include <iomanip> 5713481Sgiacomo.travaglini@arm.com#include <limits> 5813481Sgiacomo.travaglini@arm.com#include <map> 5913481Sgiacomo.travaglini@arm.com#include <set> 6013481Sgiacomo.travaglini@arm.com#include <string> 6113481Sgiacomo.travaglini@arm.com#include <vector> 6213481Sgiacomo.travaglini@arm.com 6313481Sgiacomo.travaglini@arm.com#include "gtest/gtest-message.h" 6413481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-string.h" 6513481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-filepath.h" 6613481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-type-util.h" 6713481Sgiacomo.travaglini@arm.com 6813481Sgiacomo.travaglini@arm.com// Due to C++ preprocessor weirdness, we need double indirection to 6913481Sgiacomo.travaglini@arm.com// concatenate two tokens when one of them is __LINE__. Writing 7013481Sgiacomo.travaglini@arm.com// 7113481Sgiacomo.travaglini@arm.com// foo ## __LINE__ 7213481Sgiacomo.travaglini@arm.com// 7313481Sgiacomo.travaglini@arm.com// will result in the token foo__LINE__, instead of foo followed by 7413481Sgiacomo.travaglini@arm.com// the current line number. For more details, see 7513481Sgiacomo.travaglini@arm.com// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 7613481Sgiacomo.travaglini@arm.com#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) 7713481Sgiacomo.travaglini@arm.com#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar 7813481Sgiacomo.travaglini@arm.com 7913481Sgiacomo.travaglini@arm.comclass ProtocolMessage; 8013481Sgiacomo.travaglini@arm.comnamespace proto2 { class Message; } 8113481Sgiacomo.travaglini@arm.com 8213481Sgiacomo.travaglini@arm.comnamespace testing { 8313481Sgiacomo.travaglini@arm.com 8413481Sgiacomo.travaglini@arm.com// Forward declarations. 8513481Sgiacomo.travaglini@arm.com 8613481Sgiacomo.travaglini@arm.comclass AssertionResult; // Result of an assertion. 8713481Sgiacomo.travaglini@arm.comclass Message; // Represents a failure message. 8813481Sgiacomo.travaglini@arm.comclass Test; // Represents a test. 8913481Sgiacomo.travaglini@arm.comclass TestInfo; // Information about a test. 9013481Sgiacomo.travaglini@arm.comclass TestPartResult; // Result of a test part. 9113481Sgiacomo.travaglini@arm.comclass UnitTest; // A collection of test cases. 9213481Sgiacomo.travaglini@arm.com 9313481Sgiacomo.travaglini@arm.comtemplate <typename T> 9413481Sgiacomo.travaglini@arm.com::std::string PrintToString(const T& value); 9513481Sgiacomo.travaglini@arm.com 9613481Sgiacomo.travaglini@arm.comnamespace internal { 9713481Sgiacomo.travaglini@arm.com 9813481Sgiacomo.travaglini@arm.comstruct TraceInfo; // Information about a trace point. 9913481Sgiacomo.travaglini@arm.comclass ScopedTrace; // Implements scoped trace. 10013481Sgiacomo.travaglini@arm.comclass TestInfoImpl; // Opaque implementation of TestInfo 10113481Sgiacomo.travaglini@arm.comclass UnitTestImpl; // Opaque implementation of UnitTest 10213481Sgiacomo.travaglini@arm.com 10313481Sgiacomo.travaglini@arm.com// The text used in failure messages to indicate the start of the 10413481Sgiacomo.travaglini@arm.com// stack trace. 10513481Sgiacomo.travaglini@arm.comGTEST_API_ extern const char kStackTraceMarker[]; 10613481Sgiacomo.travaglini@arm.com 10713481Sgiacomo.travaglini@arm.com// Two overloaded helpers for checking at compile time whether an 10813481Sgiacomo.travaglini@arm.com// expression is a null pointer literal (i.e. NULL or any 0-valued 10913481Sgiacomo.travaglini@arm.com// compile-time integral constant). Their return values have 11013481Sgiacomo.travaglini@arm.com// different sizes, so we can use sizeof() to test which version is 11113481Sgiacomo.travaglini@arm.com// picked by the compiler. These helpers have no implementations, as 11213481Sgiacomo.travaglini@arm.com// we only need their signatures. 11313481Sgiacomo.travaglini@arm.com// 11413481Sgiacomo.travaglini@arm.com// Given IsNullLiteralHelper(x), the compiler will pick the first 11513481Sgiacomo.travaglini@arm.com// version if x can be implicitly converted to Secret*, and pick the 11613481Sgiacomo.travaglini@arm.com// second version otherwise. Since Secret is a secret and incomplete 11713481Sgiacomo.travaglini@arm.com// type, the only expression a user can write that has type Secret* is 11813481Sgiacomo.travaglini@arm.com// a null pointer literal. Therefore, we know that x is a null 11913481Sgiacomo.travaglini@arm.com// pointer literal if and only if the first version is picked by the 12013481Sgiacomo.travaglini@arm.com// compiler. 12113481Sgiacomo.travaglini@arm.comchar IsNullLiteralHelper(Secret* p); 12213481Sgiacomo.travaglini@arm.comchar (&IsNullLiteralHelper(...))[2]; // NOLINT 12313481Sgiacomo.travaglini@arm.com 12413481Sgiacomo.travaglini@arm.com// A compile-time bool constant that is true if and only if x is a 12513481Sgiacomo.travaglini@arm.com// null pointer literal (i.e. NULL or any 0-valued compile-time 12613481Sgiacomo.travaglini@arm.com// integral constant). 12713481Sgiacomo.travaglini@arm.com#ifdef GTEST_ELLIPSIS_NEEDS_POD_ 12813481Sgiacomo.travaglini@arm.com// We lose support for NULL detection where the compiler doesn't like 12913481Sgiacomo.travaglini@arm.com// passing non-POD classes through ellipsis (...). 13013481Sgiacomo.travaglini@arm.com# define GTEST_IS_NULL_LITERAL_(x) false 13113481Sgiacomo.travaglini@arm.com#else 13213481Sgiacomo.travaglini@arm.com# define GTEST_IS_NULL_LITERAL_(x) \ 13313481Sgiacomo.travaglini@arm.com (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) 13413481Sgiacomo.travaglini@arm.com#endif // GTEST_ELLIPSIS_NEEDS_POD_ 13513481Sgiacomo.travaglini@arm.com 13613481Sgiacomo.travaglini@arm.com// Appends the user-supplied message to the Google-Test-generated message. 13713481Sgiacomo.travaglini@arm.comGTEST_API_ std::string AppendUserMessage( 13813481Sgiacomo.travaglini@arm.com const std::string& gtest_msg, const Message& user_msg); 13913481Sgiacomo.travaglini@arm.com 14013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS 14113481Sgiacomo.travaglini@arm.com 14213481Sgiacomo.travaglini@arm.com// This exception is thrown by (and only by) a failed Google Test 14313481Sgiacomo.travaglini@arm.com// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions 14413481Sgiacomo.travaglini@arm.com// are enabled). We derive it from std::runtime_error, which is for 14513481Sgiacomo.travaglini@arm.com// errors presumably detectable only at run time. Since 14613481Sgiacomo.travaglini@arm.com// std::runtime_error inherits from std::exception, many testing 14713481Sgiacomo.travaglini@arm.com// frameworks know how to extract and print the message inside it. 14813481Sgiacomo.travaglini@arm.comclass GTEST_API_ GoogleTestFailureException : public ::std::runtime_error { 14913481Sgiacomo.travaglini@arm.com public: 15013481Sgiacomo.travaglini@arm.com explicit GoogleTestFailureException(const TestPartResult& failure); 15113481Sgiacomo.travaglini@arm.com}; 15213481Sgiacomo.travaglini@arm.com 15313481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_EXCEPTIONS 15413481Sgiacomo.travaglini@arm.com 15513481Sgiacomo.travaglini@arm.com// A helper class for creating scoped traces in user programs. 15613481Sgiacomo.travaglini@arm.comclass GTEST_API_ ScopedTrace { 15713481Sgiacomo.travaglini@arm.com public: 15813481Sgiacomo.travaglini@arm.com // The c'tor pushes the given source file location and message onto 15913481Sgiacomo.travaglini@arm.com // a trace stack maintained by Google Test. 16013481Sgiacomo.travaglini@arm.com ScopedTrace(const char* file, int line, const Message& message); 16113481Sgiacomo.travaglini@arm.com 16213481Sgiacomo.travaglini@arm.com // The d'tor pops the info pushed by the c'tor. 16313481Sgiacomo.travaglini@arm.com // 16413481Sgiacomo.travaglini@arm.com // Note that the d'tor is not virtual in order to be efficient. 16513481Sgiacomo.travaglini@arm.com // Don't inherit from ScopedTrace! 16613481Sgiacomo.travaglini@arm.com ~ScopedTrace(); 16713481Sgiacomo.travaglini@arm.com 16813481Sgiacomo.travaglini@arm.com private: 16913481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); 17013481Sgiacomo.travaglini@arm.com} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its 17113481Sgiacomo.travaglini@arm.com // c'tor and d'tor. Therefore it doesn't 17213481Sgiacomo.travaglini@arm.com // need to be used otherwise. 17313481Sgiacomo.travaglini@arm.com 17413481Sgiacomo.travaglini@arm.comnamespace edit_distance { 17513481Sgiacomo.travaglini@arm.com// Returns the optimal edits to go from 'left' to 'right'. 17613481Sgiacomo.travaglini@arm.com// All edits cost the same, with replace having lower priority than 17713481Sgiacomo.travaglini@arm.com// add/remove. 17813481Sgiacomo.travaglini@arm.com// Simple implementation of the Wagner–Fischer algorithm. 17913481Sgiacomo.travaglini@arm.com// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm 18013481Sgiacomo.travaglini@arm.comenum EditType { kMatch, kAdd, kRemove, kReplace }; 18113481Sgiacomo.travaglini@arm.comGTEST_API_ std::vector<EditType> CalculateOptimalEdits( 18213481Sgiacomo.travaglini@arm.com const std::vector<size_t>& left, const std::vector<size_t>& right); 18313481Sgiacomo.travaglini@arm.com 18413481Sgiacomo.travaglini@arm.com// Same as above, but the input is represented as strings. 18513481Sgiacomo.travaglini@arm.comGTEST_API_ std::vector<EditType> CalculateOptimalEdits( 18613481Sgiacomo.travaglini@arm.com const std::vector<std::string>& left, 18713481Sgiacomo.travaglini@arm.com const std::vector<std::string>& right); 18813481Sgiacomo.travaglini@arm.com 18913481Sgiacomo.travaglini@arm.com// Create a diff of the input strings in Unified diff format. 19013481Sgiacomo.travaglini@arm.comGTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left, 19113481Sgiacomo.travaglini@arm.com const std::vector<std::string>& right, 19213481Sgiacomo.travaglini@arm.com size_t context = 2); 19313481Sgiacomo.travaglini@arm.com 19413481Sgiacomo.travaglini@arm.com} // namespace edit_distance 19513481Sgiacomo.travaglini@arm.com 19613481Sgiacomo.travaglini@arm.com// Calculate the diff between 'left' and 'right' and return it in unified diff 19713481Sgiacomo.travaglini@arm.com// format. 19813481Sgiacomo.travaglini@arm.com// If not null, stores in 'total_line_count' the total number of lines found 19913481Sgiacomo.travaglini@arm.com// in left + right. 20013481Sgiacomo.travaglini@arm.comGTEST_API_ std::string DiffStrings(const std::string& left, 20113481Sgiacomo.travaglini@arm.com const std::string& right, 20213481Sgiacomo.travaglini@arm.com size_t* total_line_count); 20313481Sgiacomo.travaglini@arm.com 20413481Sgiacomo.travaglini@arm.com// Constructs and returns the message for an equality assertion 20513481Sgiacomo.travaglini@arm.com// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. 20613481Sgiacomo.travaglini@arm.com// 20713481Sgiacomo.travaglini@arm.com// The first four parameters are the expressions used in the assertion 20813481Sgiacomo.travaglini@arm.com// and their values, as strings. For example, for ASSERT_EQ(foo, bar) 20913481Sgiacomo.travaglini@arm.com// where foo is 5 and bar is 6, we have: 21013481Sgiacomo.travaglini@arm.com// 21113481Sgiacomo.travaglini@arm.com// expected_expression: "foo" 21213481Sgiacomo.travaglini@arm.com// actual_expression: "bar" 21313481Sgiacomo.travaglini@arm.com// expected_value: "5" 21413481Sgiacomo.travaglini@arm.com// actual_value: "6" 21513481Sgiacomo.travaglini@arm.com// 21613481Sgiacomo.travaglini@arm.com// The ignoring_case parameter is true iff the assertion is a 21713481Sgiacomo.travaglini@arm.com// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will 21813481Sgiacomo.travaglini@arm.com// be inserted into the message. 21913481Sgiacomo.travaglini@arm.comGTEST_API_ AssertionResult EqFailure(const char* expected_expression, 22013481Sgiacomo.travaglini@arm.com const char* actual_expression, 22113481Sgiacomo.travaglini@arm.com const std::string& expected_value, 22213481Sgiacomo.travaglini@arm.com const std::string& actual_value, 22313481Sgiacomo.travaglini@arm.com bool ignoring_case); 22413481Sgiacomo.travaglini@arm.com 22513481Sgiacomo.travaglini@arm.com// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. 22613481Sgiacomo.travaglini@arm.comGTEST_API_ std::string GetBoolAssertionFailureMessage( 22713481Sgiacomo.travaglini@arm.com const AssertionResult& assertion_result, 22813481Sgiacomo.travaglini@arm.com const char* expression_text, 22913481Sgiacomo.travaglini@arm.com const char* actual_predicate_value, 23013481Sgiacomo.travaglini@arm.com const char* expected_predicate_value); 23113481Sgiacomo.travaglini@arm.com 23213481Sgiacomo.travaglini@arm.com// This template class represents an IEEE floating-point number 23313481Sgiacomo.travaglini@arm.com// (either single-precision or double-precision, depending on the 23413481Sgiacomo.travaglini@arm.com// template parameters). 23513481Sgiacomo.travaglini@arm.com// 23613481Sgiacomo.travaglini@arm.com// The purpose of this class is to do more sophisticated number 23713481Sgiacomo.travaglini@arm.com// comparison. (Due to round-off error, etc, it's very unlikely that 23813481Sgiacomo.travaglini@arm.com// two floating-points will be equal exactly. Hence a naive 23913481Sgiacomo.travaglini@arm.com// comparison by the == operation often doesn't work.) 24013481Sgiacomo.travaglini@arm.com// 24113481Sgiacomo.travaglini@arm.com// Format of IEEE floating-point: 24213481Sgiacomo.travaglini@arm.com// 24313481Sgiacomo.travaglini@arm.com// The most-significant bit being the leftmost, an IEEE 24413481Sgiacomo.travaglini@arm.com// floating-point looks like 24513481Sgiacomo.travaglini@arm.com// 24613481Sgiacomo.travaglini@arm.com// sign_bit exponent_bits fraction_bits 24713481Sgiacomo.travaglini@arm.com// 24813481Sgiacomo.travaglini@arm.com// Here, sign_bit is a single bit that designates the sign of the 24913481Sgiacomo.travaglini@arm.com// number. 25013481Sgiacomo.travaglini@arm.com// 25113481Sgiacomo.travaglini@arm.com// For float, there are 8 exponent bits and 23 fraction bits. 25213481Sgiacomo.travaglini@arm.com// 25313481Sgiacomo.travaglini@arm.com// For double, there are 11 exponent bits and 52 fraction bits. 25413481Sgiacomo.travaglini@arm.com// 25513481Sgiacomo.travaglini@arm.com// More details can be found at 25613481Sgiacomo.travaglini@arm.com// http://en.wikipedia.org/wiki/IEEE_floating-point_standard. 25713481Sgiacomo.travaglini@arm.com// 25813481Sgiacomo.travaglini@arm.com// Template parameter: 25913481Sgiacomo.travaglini@arm.com// 26013481Sgiacomo.travaglini@arm.com// RawType: the raw floating-point type (either float or double) 26113481Sgiacomo.travaglini@arm.comtemplate <typename RawType> 26213481Sgiacomo.travaglini@arm.comclass FloatingPoint { 26313481Sgiacomo.travaglini@arm.com public: 26413481Sgiacomo.travaglini@arm.com // Defines the unsigned integer type that has the same size as the 26513481Sgiacomo.travaglini@arm.com // floating point number. 26613481Sgiacomo.travaglini@arm.com typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits; 26713481Sgiacomo.travaglini@arm.com 26813481Sgiacomo.travaglini@arm.com // Constants. 26913481Sgiacomo.travaglini@arm.com 27013481Sgiacomo.travaglini@arm.com // # of bits in a number. 27113481Sgiacomo.travaglini@arm.com static const size_t kBitCount = 8*sizeof(RawType); 27213481Sgiacomo.travaglini@arm.com 27313481Sgiacomo.travaglini@arm.com // # of fraction bits in a number. 27413481Sgiacomo.travaglini@arm.com static const size_t kFractionBitCount = 27513481Sgiacomo.travaglini@arm.com std::numeric_limits<RawType>::digits - 1; 27613481Sgiacomo.travaglini@arm.com 27713481Sgiacomo.travaglini@arm.com // # of exponent bits in a number. 27813481Sgiacomo.travaglini@arm.com static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; 27913481Sgiacomo.travaglini@arm.com 28013481Sgiacomo.travaglini@arm.com // The mask for the sign bit. 28113481Sgiacomo.travaglini@arm.com static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1); 28213481Sgiacomo.travaglini@arm.com 28313481Sgiacomo.travaglini@arm.com // The mask for the fraction bits. 28413481Sgiacomo.travaglini@arm.com static const Bits kFractionBitMask = 28513481Sgiacomo.travaglini@arm.com ~static_cast<Bits>(0) >> (kExponentBitCount + 1); 28613481Sgiacomo.travaglini@arm.com 28713481Sgiacomo.travaglini@arm.com // The mask for the exponent bits. 28813481Sgiacomo.travaglini@arm.com static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); 28913481Sgiacomo.travaglini@arm.com 29013481Sgiacomo.travaglini@arm.com // How many ULP's (Units in the Last Place) we want to tolerate when 29113481Sgiacomo.travaglini@arm.com // comparing two numbers. The larger the value, the more error we 29213481Sgiacomo.travaglini@arm.com // allow. A 0 value means that two numbers must be exactly the same 29313481Sgiacomo.travaglini@arm.com // to be considered equal. 29413481Sgiacomo.travaglini@arm.com // 29513481Sgiacomo.travaglini@arm.com // The maximum error of a single floating-point operation is 0.5 29613481Sgiacomo.travaglini@arm.com // units in the last place. On Intel CPU's, all floating-point 29713481Sgiacomo.travaglini@arm.com // calculations are done with 80-bit precision, while double has 64 29813481Sgiacomo.travaglini@arm.com // bits. Therefore, 4 should be enough for ordinary use. 29913481Sgiacomo.travaglini@arm.com // 30013481Sgiacomo.travaglini@arm.com // See the following article for more details on ULP: 30113481Sgiacomo.travaglini@arm.com // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ 30213481Sgiacomo.travaglini@arm.com static const size_t kMaxUlps = 4; 30313481Sgiacomo.travaglini@arm.com 30413481Sgiacomo.travaglini@arm.com // Constructs a FloatingPoint from a raw floating-point number. 30513481Sgiacomo.travaglini@arm.com // 30613481Sgiacomo.travaglini@arm.com // On an Intel CPU, passing a non-normalized NAN (Not a Number) 30713481Sgiacomo.travaglini@arm.com // around may change its bits, although the new value is guaranteed 30813481Sgiacomo.travaglini@arm.com // to be also a NAN. Therefore, don't expect this constructor to 30913481Sgiacomo.travaglini@arm.com // preserve the bits in x when x is a NAN. 31013481Sgiacomo.travaglini@arm.com explicit FloatingPoint(const RawType& x) { u_.value_ = x; } 31113481Sgiacomo.travaglini@arm.com 31213481Sgiacomo.travaglini@arm.com // Static methods 31313481Sgiacomo.travaglini@arm.com 31413481Sgiacomo.travaglini@arm.com // Reinterprets a bit pattern as a floating-point number. 31513481Sgiacomo.travaglini@arm.com // 31613481Sgiacomo.travaglini@arm.com // This function is needed to test the AlmostEquals() method. 31713481Sgiacomo.travaglini@arm.com static RawType ReinterpretBits(const Bits bits) { 31813481Sgiacomo.travaglini@arm.com FloatingPoint fp(0); 31913481Sgiacomo.travaglini@arm.com fp.u_.bits_ = bits; 32013481Sgiacomo.travaglini@arm.com return fp.u_.value_; 32113481Sgiacomo.travaglini@arm.com } 32213481Sgiacomo.travaglini@arm.com 32313481Sgiacomo.travaglini@arm.com // Returns the floating-point number that represent positive infinity. 32413481Sgiacomo.travaglini@arm.com static RawType Infinity() { 32513481Sgiacomo.travaglini@arm.com return ReinterpretBits(kExponentBitMask); 32613481Sgiacomo.travaglini@arm.com } 32713481Sgiacomo.travaglini@arm.com 32813481Sgiacomo.travaglini@arm.com // Returns the maximum representable finite floating-point number. 32913481Sgiacomo.travaglini@arm.com static RawType Max(); 33013481Sgiacomo.travaglini@arm.com 33113481Sgiacomo.travaglini@arm.com // Non-static methods 33213481Sgiacomo.travaglini@arm.com 33313481Sgiacomo.travaglini@arm.com // Returns the bits that represents this number. 33413481Sgiacomo.travaglini@arm.com const Bits &bits() const { return u_.bits_; } 33513481Sgiacomo.travaglini@arm.com 33613481Sgiacomo.travaglini@arm.com // Returns the exponent bits of this number. 33713481Sgiacomo.travaglini@arm.com Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } 33813481Sgiacomo.travaglini@arm.com 33913481Sgiacomo.travaglini@arm.com // Returns the fraction bits of this number. 34013481Sgiacomo.travaglini@arm.com Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } 34113481Sgiacomo.travaglini@arm.com 34213481Sgiacomo.travaglini@arm.com // Returns the sign bit of this number. 34313481Sgiacomo.travaglini@arm.com Bits sign_bit() const { return kSignBitMask & u_.bits_; } 34413481Sgiacomo.travaglini@arm.com 34513481Sgiacomo.travaglini@arm.com // Returns true iff this is NAN (not a number). 34613481Sgiacomo.travaglini@arm.com bool is_nan() const { 34713481Sgiacomo.travaglini@arm.com // It's a NAN if the exponent bits are all ones and the fraction 34813481Sgiacomo.travaglini@arm.com // bits are not entirely zeros. 34913481Sgiacomo.travaglini@arm.com return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); 35013481Sgiacomo.travaglini@arm.com } 35113481Sgiacomo.travaglini@arm.com 35213481Sgiacomo.travaglini@arm.com // Returns true iff this number is at most kMaxUlps ULP's away from 35313481Sgiacomo.travaglini@arm.com // rhs. In particular, this function: 35413481Sgiacomo.travaglini@arm.com // 35513481Sgiacomo.travaglini@arm.com // - returns false if either number is (or both are) NAN. 35613481Sgiacomo.travaglini@arm.com // - treats really large numbers as almost equal to infinity. 35713481Sgiacomo.travaglini@arm.com // - thinks +0.0 and -0.0 are 0 DLP's apart. 35813481Sgiacomo.travaglini@arm.com bool AlmostEquals(const FloatingPoint& rhs) const { 35913481Sgiacomo.travaglini@arm.com // The IEEE standard says that any comparison operation involving 36013481Sgiacomo.travaglini@arm.com // a NAN must return false. 36113481Sgiacomo.travaglini@arm.com if (is_nan() || rhs.is_nan()) return false; 36213481Sgiacomo.travaglini@arm.com 36313481Sgiacomo.travaglini@arm.com return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) 36413481Sgiacomo.travaglini@arm.com <= kMaxUlps; 36513481Sgiacomo.travaglini@arm.com } 36613481Sgiacomo.travaglini@arm.com 36713481Sgiacomo.travaglini@arm.com private: 36813481Sgiacomo.travaglini@arm.com // The data type used to store the actual floating-point number. 36913481Sgiacomo.travaglini@arm.com union FloatingPointUnion { 37013481Sgiacomo.travaglini@arm.com RawType value_; // The raw floating-point number. 37113481Sgiacomo.travaglini@arm.com Bits bits_; // The bits that represent the number. 37213481Sgiacomo.travaglini@arm.com }; 37313481Sgiacomo.travaglini@arm.com 37413481Sgiacomo.travaglini@arm.com // Converts an integer from the sign-and-magnitude representation to 37513481Sgiacomo.travaglini@arm.com // the biased representation. More precisely, let N be 2 to the 37613481Sgiacomo.travaglini@arm.com // power of (kBitCount - 1), an integer x is represented by the 37713481Sgiacomo.travaglini@arm.com // unsigned number x + N. 37813481Sgiacomo.travaglini@arm.com // 37913481Sgiacomo.travaglini@arm.com // For instance, 38013481Sgiacomo.travaglini@arm.com // 38113481Sgiacomo.travaglini@arm.com // -N + 1 (the most negative number representable using 38213481Sgiacomo.travaglini@arm.com // sign-and-magnitude) is represented by 1; 38313481Sgiacomo.travaglini@arm.com // 0 is represented by N; and 38413481Sgiacomo.travaglini@arm.com // N - 1 (the biggest number representable using 38513481Sgiacomo.travaglini@arm.com // sign-and-magnitude) is represented by 2N - 1. 38613481Sgiacomo.travaglini@arm.com // 38713481Sgiacomo.travaglini@arm.com // Read http://en.wikipedia.org/wiki/Signed_number_representations 38813481Sgiacomo.travaglini@arm.com // for more details on signed number representations. 38913481Sgiacomo.travaglini@arm.com static Bits SignAndMagnitudeToBiased(const Bits &sam) { 39013481Sgiacomo.travaglini@arm.com if (kSignBitMask & sam) { 39113481Sgiacomo.travaglini@arm.com // sam represents a negative number. 39213481Sgiacomo.travaglini@arm.com return ~sam + 1; 39313481Sgiacomo.travaglini@arm.com } else { 39413481Sgiacomo.travaglini@arm.com // sam represents a positive number. 39513481Sgiacomo.travaglini@arm.com return kSignBitMask | sam; 39613481Sgiacomo.travaglini@arm.com } 39713481Sgiacomo.travaglini@arm.com } 39813481Sgiacomo.travaglini@arm.com 39913481Sgiacomo.travaglini@arm.com // Given two numbers in the sign-and-magnitude representation, 40013481Sgiacomo.travaglini@arm.com // returns the distance between them as an unsigned number. 40113481Sgiacomo.travaglini@arm.com static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, 40213481Sgiacomo.travaglini@arm.com const Bits &sam2) { 40313481Sgiacomo.travaglini@arm.com const Bits biased1 = SignAndMagnitudeToBiased(sam1); 40413481Sgiacomo.travaglini@arm.com const Bits biased2 = SignAndMagnitudeToBiased(sam2); 40513481Sgiacomo.travaglini@arm.com return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); 40613481Sgiacomo.travaglini@arm.com } 40713481Sgiacomo.travaglini@arm.com 40813481Sgiacomo.travaglini@arm.com FloatingPointUnion u_; 40913481Sgiacomo.travaglini@arm.com}; 41013481Sgiacomo.travaglini@arm.com 41113481Sgiacomo.travaglini@arm.com// We cannot use std::numeric_limits<T>::max() as it clashes with the max() 41213481Sgiacomo.travaglini@arm.com// macro defined by <windows.h>. 41313481Sgiacomo.travaglini@arm.comtemplate <> 41413481Sgiacomo.travaglini@arm.cominline float FloatingPoint<float>::Max() { return FLT_MAX; } 41513481Sgiacomo.travaglini@arm.comtemplate <> 41613481Sgiacomo.travaglini@arm.cominline double FloatingPoint<double>::Max() { return DBL_MAX; } 41713481Sgiacomo.travaglini@arm.com 41813481Sgiacomo.travaglini@arm.com// Typedefs the instances of the FloatingPoint template class that we 41913481Sgiacomo.travaglini@arm.com// care to use. 42013481Sgiacomo.travaglini@arm.comtypedef FloatingPoint<float> Float; 42113481Sgiacomo.travaglini@arm.comtypedef FloatingPoint<double> Double; 42213481Sgiacomo.travaglini@arm.com 42313481Sgiacomo.travaglini@arm.com// In order to catch the mistake of putting tests that use different 42413481Sgiacomo.travaglini@arm.com// test fixture classes in the same test case, we need to assign 42513481Sgiacomo.travaglini@arm.com// unique IDs to fixture classes and compare them. The TypeId type is 42613481Sgiacomo.travaglini@arm.com// used to hold such IDs. The user should treat TypeId as an opaque 42713481Sgiacomo.travaglini@arm.com// type: the only operation allowed on TypeId values is to compare 42813481Sgiacomo.travaglini@arm.com// them for equality using the == operator. 42913481Sgiacomo.travaglini@arm.comtypedef const void* TypeId; 43013481Sgiacomo.travaglini@arm.com 43113481Sgiacomo.travaglini@arm.comtemplate <typename T> 43213481Sgiacomo.travaglini@arm.comclass TypeIdHelper { 43313481Sgiacomo.travaglini@arm.com public: 43413481Sgiacomo.travaglini@arm.com // dummy_ must not have a const type. Otherwise an overly eager 43513481Sgiacomo.travaglini@arm.com // compiler (e.g. MSVC 7.1 & 8.0) may try to merge 43613481Sgiacomo.travaglini@arm.com // TypeIdHelper<T>::dummy_ for different Ts as an "optimization". 43713481Sgiacomo.travaglini@arm.com static bool dummy_; 43813481Sgiacomo.travaglini@arm.com}; 43913481Sgiacomo.travaglini@arm.com 44013481Sgiacomo.travaglini@arm.comtemplate <typename T> 44113481Sgiacomo.travaglini@arm.combool TypeIdHelper<T>::dummy_ = false; 44213481Sgiacomo.travaglini@arm.com 44313481Sgiacomo.travaglini@arm.com// GetTypeId<T>() returns the ID of type T. Different values will be 44413481Sgiacomo.travaglini@arm.com// returned for different types. Calling the function twice with the 44513481Sgiacomo.travaglini@arm.com// same type argument is guaranteed to return the same ID. 44613481Sgiacomo.travaglini@arm.comtemplate <typename T> 44713481Sgiacomo.travaglini@arm.comTypeId GetTypeId() { 44813481Sgiacomo.travaglini@arm.com // The compiler is required to allocate a different 44913481Sgiacomo.travaglini@arm.com // TypeIdHelper<T>::dummy_ variable for each T used to instantiate 45013481Sgiacomo.travaglini@arm.com // the template. Therefore, the address of dummy_ is guaranteed to 45113481Sgiacomo.travaglini@arm.com // be unique. 45213481Sgiacomo.travaglini@arm.com return &(TypeIdHelper<T>::dummy_); 45313481Sgiacomo.travaglini@arm.com} 45413481Sgiacomo.travaglini@arm.com 45513481Sgiacomo.travaglini@arm.com// Returns the type ID of ::testing::Test. Always call this instead 45613481Sgiacomo.travaglini@arm.com// of GetTypeId< ::testing::Test>() to get the type ID of 45713481Sgiacomo.travaglini@arm.com// ::testing::Test, as the latter may give the wrong result due to a 45813481Sgiacomo.travaglini@arm.com// suspected linker bug when compiling Google Test as a Mac OS X 45913481Sgiacomo.travaglini@arm.com// framework. 46013481Sgiacomo.travaglini@arm.comGTEST_API_ TypeId GetTestTypeId(); 46113481Sgiacomo.travaglini@arm.com 46213481Sgiacomo.travaglini@arm.com// Defines the abstract factory interface that creates instances 46313481Sgiacomo.travaglini@arm.com// of a Test object. 46413481Sgiacomo.travaglini@arm.comclass TestFactoryBase { 46513481Sgiacomo.travaglini@arm.com public: 46613481Sgiacomo.travaglini@arm.com virtual ~TestFactoryBase() {} 46713481Sgiacomo.travaglini@arm.com 46813481Sgiacomo.travaglini@arm.com // Creates a test instance to run. The instance is both created and destroyed 46913481Sgiacomo.travaglini@arm.com // within TestInfoImpl::Run() 47013481Sgiacomo.travaglini@arm.com virtual Test* CreateTest() = 0; 47113481Sgiacomo.travaglini@arm.com 47213481Sgiacomo.travaglini@arm.com protected: 47313481Sgiacomo.travaglini@arm.com TestFactoryBase() {} 47413481Sgiacomo.travaglini@arm.com 47513481Sgiacomo.travaglini@arm.com private: 47613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); 47713481Sgiacomo.travaglini@arm.com}; 47813481Sgiacomo.travaglini@arm.com 47913481Sgiacomo.travaglini@arm.com// This class provides implementation of TeastFactoryBase interface. 48013481Sgiacomo.travaglini@arm.com// It is used in TEST and TEST_F macros. 48113481Sgiacomo.travaglini@arm.comtemplate <class TestClass> 48213481Sgiacomo.travaglini@arm.comclass TestFactoryImpl : public TestFactoryBase { 48313481Sgiacomo.travaglini@arm.com public: 48413481Sgiacomo.travaglini@arm.com virtual Test* CreateTest() { return new TestClass; } 48513481Sgiacomo.travaglini@arm.com}; 48613481Sgiacomo.travaglini@arm.com 48713481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 48813481Sgiacomo.travaglini@arm.com 48913481Sgiacomo.travaglini@arm.com// Predicate-formatters for implementing the HRESULT checking macros 49013481Sgiacomo.travaglini@arm.com// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} 49113481Sgiacomo.travaglini@arm.com// We pass a long instead of HRESULT to avoid causing an 49213481Sgiacomo.travaglini@arm.com// include dependency for the HRESULT type. 49313481Sgiacomo.travaglini@arm.comGTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, 49413481Sgiacomo.travaglini@arm.com long hr); // NOLINT 49513481Sgiacomo.travaglini@arm.comGTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, 49613481Sgiacomo.travaglini@arm.com long hr); // NOLINT 49713481Sgiacomo.travaglini@arm.com 49813481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 49913481Sgiacomo.travaglini@arm.com 50013481Sgiacomo.travaglini@arm.com// Types of SetUpTestCase() and TearDownTestCase() functions. 50113481Sgiacomo.travaglini@arm.comtypedef void (*SetUpTestCaseFunc)(); 50213481Sgiacomo.travaglini@arm.comtypedef void (*TearDownTestCaseFunc)(); 50313481Sgiacomo.travaglini@arm.com 50413481Sgiacomo.travaglini@arm.comstruct CodeLocation { 50513481Sgiacomo.travaglini@arm.com CodeLocation(const string& a_file, int a_line) : file(a_file), line(a_line) {} 50613481Sgiacomo.travaglini@arm.com 50713481Sgiacomo.travaglini@arm.com string file; 50813481Sgiacomo.travaglini@arm.com int line; 50913481Sgiacomo.travaglini@arm.com}; 51013481Sgiacomo.travaglini@arm.com 51113481Sgiacomo.travaglini@arm.com// Creates a new TestInfo object and registers it with Google Test; 51213481Sgiacomo.travaglini@arm.com// returns the created object. 51313481Sgiacomo.travaglini@arm.com// 51413481Sgiacomo.travaglini@arm.com// Arguments: 51513481Sgiacomo.travaglini@arm.com// 51613481Sgiacomo.travaglini@arm.com// test_case_name: name of the test case 51713481Sgiacomo.travaglini@arm.com// name: name of the test 51813481Sgiacomo.travaglini@arm.com// type_param the name of the test's type parameter, or NULL if 51913481Sgiacomo.travaglini@arm.com// this is not a typed or a type-parameterized test. 52013481Sgiacomo.travaglini@arm.com// value_param text representation of the test's value parameter, 52113481Sgiacomo.travaglini@arm.com// or NULL if this is not a type-parameterized test. 52213481Sgiacomo.travaglini@arm.com// code_location: code location where the test is defined 52313481Sgiacomo.travaglini@arm.com// fixture_class_id: ID of the test fixture class 52413481Sgiacomo.travaglini@arm.com// set_up_tc: pointer to the function that sets up the test case 52513481Sgiacomo.travaglini@arm.com// tear_down_tc: pointer to the function that tears down the test case 52613481Sgiacomo.travaglini@arm.com// factory: pointer to the factory that creates a test object. 52713481Sgiacomo.travaglini@arm.com// The newly created TestInfo instance will assume 52813481Sgiacomo.travaglini@arm.com// ownership of the factory object. 52913481Sgiacomo.travaglini@arm.comGTEST_API_ TestInfo* MakeAndRegisterTestInfo( 53013481Sgiacomo.travaglini@arm.com const char* test_case_name, 53113481Sgiacomo.travaglini@arm.com const char* name, 53213481Sgiacomo.travaglini@arm.com const char* type_param, 53313481Sgiacomo.travaglini@arm.com const char* value_param, 53413481Sgiacomo.travaglini@arm.com CodeLocation code_location, 53513481Sgiacomo.travaglini@arm.com TypeId fixture_class_id, 53613481Sgiacomo.travaglini@arm.com SetUpTestCaseFunc set_up_tc, 53713481Sgiacomo.travaglini@arm.com TearDownTestCaseFunc tear_down_tc, 53813481Sgiacomo.travaglini@arm.com TestFactoryBase* factory); 53913481Sgiacomo.travaglini@arm.com 54013481Sgiacomo.travaglini@arm.com// If *pstr starts with the given prefix, modifies *pstr to be right 54113481Sgiacomo.travaglini@arm.com// past the prefix and returns true; otherwise leaves *pstr unchanged 54213481Sgiacomo.travaglini@arm.com// and returns false. None of pstr, *pstr, and prefix can be NULL. 54313481Sgiacomo.travaglini@arm.comGTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); 54413481Sgiacomo.travaglini@arm.com 54513481Sgiacomo.travaglini@arm.com#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P 54613481Sgiacomo.travaglini@arm.com 54713481Sgiacomo.travaglini@arm.com// State of the definition of a type-parameterized test case. 54813481Sgiacomo.travaglini@arm.comclass GTEST_API_ TypedTestCasePState { 54913481Sgiacomo.travaglini@arm.com public: 55013481Sgiacomo.travaglini@arm.com TypedTestCasePState() : registered_(false) {} 55113481Sgiacomo.travaglini@arm.com 55213481Sgiacomo.travaglini@arm.com // Adds the given test name to defined_test_names_ and return true 55313481Sgiacomo.travaglini@arm.com // if the test case hasn't been registered; otherwise aborts the 55413481Sgiacomo.travaglini@arm.com // program. 55513481Sgiacomo.travaglini@arm.com bool AddTestName(const char* file, int line, const char* case_name, 55613481Sgiacomo.travaglini@arm.com const char* test_name) { 55713481Sgiacomo.travaglini@arm.com if (registered_) { 55813481Sgiacomo.travaglini@arm.com fprintf(stderr, "%s Test %s must be defined before " 55913481Sgiacomo.travaglini@arm.com "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n", 56013481Sgiacomo.travaglini@arm.com FormatFileLocation(file, line).c_str(), test_name, case_name); 56113481Sgiacomo.travaglini@arm.com fflush(stderr); 56213481Sgiacomo.travaglini@arm.com posix::Abort(); 56313481Sgiacomo.travaglini@arm.com } 56413481Sgiacomo.travaglini@arm.com registered_tests_.insert( 56513481Sgiacomo.travaglini@arm.com ::std::make_pair(test_name, CodeLocation(file, line))); 56613481Sgiacomo.travaglini@arm.com return true; 56713481Sgiacomo.travaglini@arm.com } 56813481Sgiacomo.travaglini@arm.com 56913481Sgiacomo.travaglini@arm.com bool TestExists(const std::string& test_name) const { 57013481Sgiacomo.travaglini@arm.com return registered_tests_.count(test_name) > 0; 57113481Sgiacomo.travaglini@arm.com } 57213481Sgiacomo.travaglini@arm.com 57313481Sgiacomo.travaglini@arm.com const CodeLocation& GetCodeLocation(const std::string& test_name) const { 57413481Sgiacomo.travaglini@arm.com RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name); 57513481Sgiacomo.travaglini@arm.com GTEST_CHECK_(it != registered_tests_.end()); 57613481Sgiacomo.travaglini@arm.com return it->second; 57713481Sgiacomo.travaglini@arm.com } 57813481Sgiacomo.travaglini@arm.com 57913481Sgiacomo.travaglini@arm.com // Verifies that registered_tests match the test names in 58013481Sgiacomo.travaglini@arm.com // defined_test_names_; returns registered_tests if successful, or 58113481Sgiacomo.travaglini@arm.com // aborts the program otherwise. 58213481Sgiacomo.travaglini@arm.com const char* VerifyRegisteredTestNames( 58313481Sgiacomo.travaglini@arm.com const char* file, int line, const char* registered_tests); 58413481Sgiacomo.travaglini@arm.com 58513481Sgiacomo.travaglini@arm.com private: 58613481Sgiacomo.travaglini@arm.com typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap; 58713481Sgiacomo.travaglini@arm.com 58813481Sgiacomo.travaglini@arm.com bool registered_; 58913481Sgiacomo.travaglini@arm.com RegisteredTestsMap registered_tests_; 59013481Sgiacomo.travaglini@arm.com}; 59113481Sgiacomo.travaglini@arm.com 59213481Sgiacomo.travaglini@arm.com// Skips to the first non-space char after the first comma in 'str'; 59313481Sgiacomo.travaglini@arm.com// returns NULL if no comma is found in 'str'. 59413481Sgiacomo.travaglini@arm.cominline const char* SkipComma(const char* str) { 59513481Sgiacomo.travaglini@arm.com const char* comma = strchr(str, ','); 59613481Sgiacomo.travaglini@arm.com if (comma == NULL) { 59713481Sgiacomo.travaglini@arm.com return NULL; 59813481Sgiacomo.travaglini@arm.com } 59913481Sgiacomo.travaglini@arm.com while (IsSpace(*(++comma))) {} 60013481Sgiacomo.travaglini@arm.com return comma; 60113481Sgiacomo.travaglini@arm.com} 60213481Sgiacomo.travaglini@arm.com 60313481Sgiacomo.travaglini@arm.com// Returns the prefix of 'str' before the first comma in it; returns 60413481Sgiacomo.travaglini@arm.com// the entire string if it contains no comma. 60513481Sgiacomo.travaglini@arm.cominline std::string GetPrefixUntilComma(const char* str) { 60613481Sgiacomo.travaglini@arm.com const char* comma = strchr(str, ','); 60713481Sgiacomo.travaglini@arm.com return comma == NULL ? str : std::string(str, comma); 60813481Sgiacomo.travaglini@arm.com} 60913481Sgiacomo.travaglini@arm.com 61013481Sgiacomo.travaglini@arm.com// Splits a given string on a given delimiter, populating a given 61113481Sgiacomo.travaglini@arm.com// vector with the fields. 61213481Sgiacomo.travaglini@arm.comvoid SplitString(const ::std::string& str, char delimiter, 61313481Sgiacomo.travaglini@arm.com ::std::vector< ::std::string>* dest); 61413481Sgiacomo.travaglini@arm.com 61513481Sgiacomo.travaglini@arm.com// TypeParameterizedTest<Fixture, TestSel, Types>::Register() 61613481Sgiacomo.travaglini@arm.com// registers a list of type-parameterized tests with Google Test. The 61713481Sgiacomo.travaglini@arm.com// return value is insignificant - we just need to return something 61813481Sgiacomo.travaglini@arm.com// such that we can call this function in a namespace scope. 61913481Sgiacomo.travaglini@arm.com// 62013481Sgiacomo.travaglini@arm.com// Implementation note: The GTEST_TEMPLATE_ macro declares a template 62113481Sgiacomo.travaglini@arm.com// template parameter. It's defined in gtest-type-util.h. 62213481Sgiacomo.travaglini@arm.comtemplate <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types> 62313481Sgiacomo.travaglini@arm.comclass TypeParameterizedTest { 62413481Sgiacomo.travaglini@arm.com public: 62513481Sgiacomo.travaglini@arm.com // 'index' is the index of the test in the type list 'Types' 62613481Sgiacomo.travaglini@arm.com // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase, 62713481Sgiacomo.travaglini@arm.com // Types). Valid values for 'index' are [0, N - 1] where N is the 62813481Sgiacomo.travaglini@arm.com // length of Types. 62913481Sgiacomo.travaglini@arm.com static bool Register(const char* prefix, 63013481Sgiacomo.travaglini@arm.com CodeLocation code_location, 63113481Sgiacomo.travaglini@arm.com const char* case_name, const char* test_names, 63213481Sgiacomo.travaglini@arm.com int index) { 63313481Sgiacomo.travaglini@arm.com typedef typename Types::Head Type; 63413481Sgiacomo.travaglini@arm.com typedef Fixture<Type> FixtureClass; 63513481Sgiacomo.travaglini@arm.com typedef typename GTEST_BIND_(TestSel, Type) TestClass; 63613481Sgiacomo.travaglini@arm.com 63713481Sgiacomo.travaglini@arm.com // First, registers the first type-parameterized test in the type 63813481Sgiacomo.travaglini@arm.com // list. 63913481Sgiacomo.travaglini@arm.com MakeAndRegisterTestInfo( 64013481Sgiacomo.travaglini@arm.com (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/" 64113481Sgiacomo.travaglini@arm.com + StreamableToString(index)).c_str(), 64213481Sgiacomo.travaglini@arm.com StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(), 64313481Sgiacomo.travaglini@arm.com GetTypeName<Type>().c_str(), 64413481Sgiacomo.travaglini@arm.com NULL, // No value parameter. 64513481Sgiacomo.travaglini@arm.com code_location, 64613481Sgiacomo.travaglini@arm.com GetTypeId<FixtureClass>(), 64713481Sgiacomo.travaglini@arm.com TestClass::SetUpTestCase, 64813481Sgiacomo.travaglini@arm.com TestClass::TearDownTestCase, 64913481Sgiacomo.travaglini@arm.com new TestFactoryImpl<TestClass>); 65013481Sgiacomo.travaglini@arm.com 65113481Sgiacomo.travaglini@arm.com // Next, recurses (at compile time) with the tail of the type list. 65213481Sgiacomo.travaglini@arm.com return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail> 65313481Sgiacomo.travaglini@arm.com ::Register(prefix, code_location, case_name, test_names, index + 1); 65413481Sgiacomo.travaglini@arm.com } 65513481Sgiacomo.travaglini@arm.com}; 65613481Sgiacomo.travaglini@arm.com 65713481Sgiacomo.travaglini@arm.com// The base case for the compile time recursion. 65813481Sgiacomo.travaglini@arm.comtemplate <GTEST_TEMPLATE_ Fixture, class TestSel> 65913481Sgiacomo.travaglini@arm.comclass TypeParameterizedTest<Fixture, TestSel, Types0> { 66013481Sgiacomo.travaglini@arm.com public: 66113481Sgiacomo.travaglini@arm.com static bool Register(const char* /*prefix*/, CodeLocation, 66213481Sgiacomo.travaglini@arm.com const char* /*case_name*/, const char* /*test_names*/, 66313481Sgiacomo.travaglini@arm.com int /*index*/) { 66413481Sgiacomo.travaglini@arm.com return true; 66513481Sgiacomo.travaglini@arm.com } 66613481Sgiacomo.travaglini@arm.com}; 66713481Sgiacomo.travaglini@arm.com 66813481Sgiacomo.travaglini@arm.com// TypeParameterizedTestCase<Fixture, Tests, Types>::Register() 66913481Sgiacomo.travaglini@arm.com// registers *all combinations* of 'Tests' and 'Types' with Google 67013481Sgiacomo.travaglini@arm.com// Test. The return value is insignificant - we just need to return 67113481Sgiacomo.travaglini@arm.com// something such that we can call this function in a namespace scope. 67213481Sgiacomo.travaglini@arm.comtemplate <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types> 67313481Sgiacomo.travaglini@arm.comclass TypeParameterizedTestCase { 67413481Sgiacomo.travaglini@arm.com public: 67513481Sgiacomo.travaglini@arm.com static bool Register(const char* prefix, CodeLocation code_location, 67613481Sgiacomo.travaglini@arm.com const TypedTestCasePState* state, 67713481Sgiacomo.travaglini@arm.com const char* case_name, const char* test_names) { 67813481Sgiacomo.travaglini@arm.com std::string test_name = StripTrailingSpaces( 67913481Sgiacomo.travaglini@arm.com GetPrefixUntilComma(test_names)); 68013481Sgiacomo.travaglini@arm.com if (!state->TestExists(test_name)) { 68113481Sgiacomo.travaglini@arm.com fprintf(stderr, "Failed to get code location for test %s.%s at %s.", 68213481Sgiacomo.travaglini@arm.com case_name, test_name.c_str(), 68313481Sgiacomo.travaglini@arm.com FormatFileLocation(code_location.file.c_str(), 68413481Sgiacomo.travaglini@arm.com code_location.line).c_str()); 68513481Sgiacomo.travaglini@arm.com fflush(stderr); 68613481Sgiacomo.travaglini@arm.com posix::Abort(); 68713481Sgiacomo.travaglini@arm.com } 68813481Sgiacomo.travaglini@arm.com const CodeLocation& test_location = state->GetCodeLocation(test_name); 68913481Sgiacomo.travaglini@arm.com 69013481Sgiacomo.travaglini@arm.com typedef typename Tests::Head Head; 69113481Sgiacomo.travaglini@arm.com 69213481Sgiacomo.travaglini@arm.com // First, register the first test in 'Test' for each type in 'Types'. 69313481Sgiacomo.travaglini@arm.com TypeParameterizedTest<Fixture, Head, Types>::Register( 69413481Sgiacomo.travaglini@arm.com prefix, test_location, case_name, test_names, 0); 69513481Sgiacomo.travaglini@arm.com 69613481Sgiacomo.travaglini@arm.com // Next, recurses (at compile time) with the tail of the test list. 69713481Sgiacomo.travaglini@arm.com return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types> 69813481Sgiacomo.travaglini@arm.com ::Register(prefix, code_location, state, 69913481Sgiacomo.travaglini@arm.com case_name, SkipComma(test_names)); 70013481Sgiacomo.travaglini@arm.com } 70113481Sgiacomo.travaglini@arm.com}; 70213481Sgiacomo.travaglini@arm.com 70313481Sgiacomo.travaglini@arm.com// The base case for the compile time recursion. 70413481Sgiacomo.travaglini@arm.comtemplate <GTEST_TEMPLATE_ Fixture, typename Types> 70513481Sgiacomo.travaglini@arm.comclass TypeParameterizedTestCase<Fixture, Templates0, Types> { 70613481Sgiacomo.travaglini@arm.com public: 70713481Sgiacomo.travaglini@arm.com static bool Register(const char* /*prefix*/, CodeLocation, 70813481Sgiacomo.travaglini@arm.com const TypedTestCasePState* /*state*/, 70913481Sgiacomo.travaglini@arm.com const char* /*case_name*/, const char* /*test_names*/) { 71013481Sgiacomo.travaglini@arm.com return true; 71113481Sgiacomo.travaglini@arm.com } 71213481Sgiacomo.travaglini@arm.com}; 71313481Sgiacomo.travaglini@arm.com 71413481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P 71513481Sgiacomo.travaglini@arm.com 71613481Sgiacomo.travaglini@arm.com// Returns the current OS stack trace as an std::string. 71713481Sgiacomo.travaglini@arm.com// 71813481Sgiacomo.travaglini@arm.com// The maximum number of stack frames to be included is specified by 71913481Sgiacomo.travaglini@arm.com// the gtest_stack_trace_depth flag. The skip_count parameter 72013481Sgiacomo.travaglini@arm.com// specifies the number of top frames to be skipped, which doesn't 72113481Sgiacomo.travaglini@arm.com// count against the number of frames to be included. 72213481Sgiacomo.travaglini@arm.com// 72313481Sgiacomo.travaglini@arm.com// For example, if Foo() calls Bar(), which in turn calls 72413481Sgiacomo.travaglini@arm.com// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in 72513481Sgiacomo.travaglini@arm.com// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. 72613481Sgiacomo.travaglini@arm.comGTEST_API_ std::string GetCurrentOsStackTraceExceptTop( 72713481Sgiacomo.travaglini@arm.com UnitTest* unit_test, int skip_count); 72813481Sgiacomo.travaglini@arm.com 72913481Sgiacomo.travaglini@arm.com// Helpers for suppressing warnings on unreachable code or constant 73013481Sgiacomo.travaglini@arm.com// condition. 73113481Sgiacomo.travaglini@arm.com 73213481Sgiacomo.travaglini@arm.com// Always returns true. 73313481Sgiacomo.travaglini@arm.comGTEST_API_ bool AlwaysTrue(); 73413481Sgiacomo.travaglini@arm.com 73513481Sgiacomo.travaglini@arm.com// Always returns false. 73613481Sgiacomo.travaglini@arm.cominline bool AlwaysFalse() { return !AlwaysTrue(); } 73713481Sgiacomo.travaglini@arm.com 73813481Sgiacomo.travaglini@arm.com// Helper for suppressing false warning from Clang on a const char* 73913481Sgiacomo.travaglini@arm.com// variable declared in a conditional expression always being NULL in 74013481Sgiacomo.travaglini@arm.com// the else branch. 74113481Sgiacomo.travaglini@arm.comstruct GTEST_API_ ConstCharPtr { 74213481Sgiacomo.travaglini@arm.com ConstCharPtr(const char* str) : value(str) {} 74313481Sgiacomo.travaglini@arm.com operator bool() const { return true; } 74413481Sgiacomo.travaglini@arm.com const char* value; 74513481Sgiacomo.travaglini@arm.com}; 74613481Sgiacomo.travaglini@arm.com 74713481Sgiacomo.travaglini@arm.com// A simple Linear Congruential Generator for generating random 74813481Sgiacomo.travaglini@arm.com// numbers with a uniform distribution. Unlike rand() and srand(), it 74913481Sgiacomo.travaglini@arm.com// doesn't use global state (and therefore can't interfere with user 75013481Sgiacomo.travaglini@arm.com// code). Unlike rand_r(), it's portable. An LCG isn't very random, 75113481Sgiacomo.travaglini@arm.com// but it's good enough for our purposes. 75213481Sgiacomo.travaglini@arm.comclass GTEST_API_ Random { 75313481Sgiacomo.travaglini@arm.com public: 75413481Sgiacomo.travaglini@arm.com static const UInt32 kMaxRange = 1u << 31; 75513481Sgiacomo.travaglini@arm.com 75613481Sgiacomo.travaglini@arm.com explicit Random(UInt32 seed) : state_(seed) {} 75713481Sgiacomo.travaglini@arm.com 75813481Sgiacomo.travaglini@arm.com void Reseed(UInt32 seed) { state_ = seed; } 75913481Sgiacomo.travaglini@arm.com 76013481Sgiacomo.travaglini@arm.com // Generates a random number from [0, range). Crashes if 'range' is 76113481Sgiacomo.travaglini@arm.com // 0 or greater than kMaxRange. 76213481Sgiacomo.travaglini@arm.com UInt32 Generate(UInt32 range); 76313481Sgiacomo.travaglini@arm.com 76413481Sgiacomo.travaglini@arm.com private: 76513481Sgiacomo.travaglini@arm.com UInt32 state_; 76613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); 76713481Sgiacomo.travaglini@arm.com}; 76813481Sgiacomo.travaglini@arm.com 76913481Sgiacomo.travaglini@arm.com// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a 77013481Sgiacomo.travaglini@arm.com// compiler error iff T1 and T2 are different types. 77113481Sgiacomo.travaglini@arm.comtemplate <typename T1, typename T2> 77213481Sgiacomo.travaglini@arm.comstruct CompileAssertTypesEqual; 77313481Sgiacomo.travaglini@arm.com 77413481Sgiacomo.travaglini@arm.comtemplate <typename T> 77513481Sgiacomo.travaglini@arm.comstruct CompileAssertTypesEqual<T, T> { 77613481Sgiacomo.travaglini@arm.com}; 77713481Sgiacomo.travaglini@arm.com 77813481Sgiacomo.travaglini@arm.com// Removes the reference from a type if it is a reference type, 77913481Sgiacomo.travaglini@arm.com// otherwise leaves it unchanged. This is the same as 78013481Sgiacomo.travaglini@arm.com// tr1::remove_reference, which is not widely available yet. 78113481Sgiacomo.travaglini@arm.comtemplate <typename T> 78213481Sgiacomo.travaglini@arm.comstruct RemoveReference { typedef T type; }; // NOLINT 78313481Sgiacomo.travaglini@arm.comtemplate <typename T> 78413481Sgiacomo.travaglini@arm.comstruct RemoveReference<T&> { typedef T type; }; // NOLINT 78513481Sgiacomo.travaglini@arm.com 78613481Sgiacomo.travaglini@arm.com// A handy wrapper around RemoveReference that works when the argument 78713481Sgiacomo.travaglini@arm.com// T depends on template parameters. 78813481Sgiacomo.travaglini@arm.com#define GTEST_REMOVE_REFERENCE_(T) \ 78913481Sgiacomo.travaglini@arm.com typename ::testing::internal::RemoveReference<T>::type 79013481Sgiacomo.travaglini@arm.com 79113481Sgiacomo.travaglini@arm.com// Removes const from a type if it is a const type, otherwise leaves 79213481Sgiacomo.travaglini@arm.com// it unchanged. This is the same as tr1::remove_const, which is not 79313481Sgiacomo.travaglini@arm.com// widely available yet. 79413481Sgiacomo.travaglini@arm.comtemplate <typename T> 79513481Sgiacomo.travaglini@arm.comstruct RemoveConst { typedef T type; }; // NOLINT 79613481Sgiacomo.travaglini@arm.comtemplate <typename T> 79713481Sgiacomo.travaglini@arm.comstruct RemoveConst<const T> { typedef T type; }; // NOLINT 79813481Sgiacomo.travaglini@arm.com 79913481Sgiacomo.travaglini@arm.com// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above 80013481Sgiacomo.travaglini@arm.com// definition to fail to remove the const in 'const int[3]' and 'const 80113481Sgiacomo.travaglini@arm.com// char[3][4]'. The following specialization works around the bug. 80213481Sgiacomo.travaglini@arm.comtemplate <typename T, size_t N> 80313481Sgiacomo.travaglini@arm.comstruct RemoveConst<const T[N]> { 80413481Sgiacomo.travaglini@arm.com typedef typename RemoveConst<T>::type type[N]; 80513481Sgiacomo.travaglini@arm.com}; 80613481Sgiacomo.travaglini@arm.com 80713481Sgiacomo.travaglini@arm.com#if defined(_MSC_VER) && _MSC_VER < 1400 80813481Sgiacomo.travaglini@arm.com// This is the only specialization that allows VC++ 7.1 to remove const in 80913481Sgiacomo.travaglini@arm.com// 'const int[3] and 'const int[3][4]'. However, it causes trouble with GCC 81013481Sgiacomo.travaglini@arm.com// and thus needs to be conditionally compiled. 81113481Sgiacomo.travaglini@arm.comtemplate <typename T, size_t N> 81213481Sgiacomo.travaglini@arm.comstruct RemoveConst<T[N]> { 81313481Sgiacomo.travaglini@arm.com typedef typename RemoveConst<T>::type type[N]; 81413481Sgiacomo.travaglini@arm.com}; 81513481Sgiacomo.travaglini@arm.com#endif 81613481Sgiacomo.travaglini@arm.com 81713481Sgiacomo.travaglini@arm.com// A handy wrapper around RemoveConst that works when the argument 81813481Sgiacomo.travaglini@arm.com// T depends on template parameters. 81913481Sgiacomo.travaglini@arm.com#define GTEST_REMOVE_CONST_(T) \ 82013481Sgiacomo.travaglini@arm.com typename ::testing::internal::RemoveConst<T>::type 82113481Sgiacomo.travaglini@arm.com 82213481Sgiacomo.travaglini@arm.com// Turns const U&, U&, const U, and U all into U. 82313481Sgiacomo.travaglini@arm.com#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ 82413481Sgiacomo.travaglini@arm.com GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) 82513481Sgiacomo.travaglini@arm.com 82613481Sgiacomo.travaglini@arm.com// Adds reference to a type if it is not a reference type, 82713481Sgiacomo.travaglini@arm.com// otherwise leaves it unchanged. This is the same as 82813481Sgiacomo.travaglini@arm.com// tr1::add_reference, which is not widely available yet. 82913481Sgiacomo.travaglini@arm.comtemplate <typename T> 83013481Sgiacomo.travaglini@arm.comstruct AddReference { typedef T& type; }; // NOLINT 83113481Sgiacomo.travaglini@arm.comtemplate <typename T> 83213481Sgiacomo.travaglini@arm.comstruct AddReference<T&> { typedef T& type; }; // NOLINT 83313481Sgiacomo.travaglini@arm.com 83413481Sgiacomo.travaglini@arm.com// A handy wrapper around AddReference that works when the argument T 83513481Sgiacomo.travaglini@arm.com// depends on template parameters. 83613481Sgiacomo.travaglini@arm.com#define GTEST_ADD_REFERENCE_(T) \ 83713481Sgiacomo.travaglini@arm.com typename ::testing::internal::AddReference<T>::type 83813481Sgiacomo.travaglini@arm.com 83913481Sgiacomo.travaglini@arm.com// Adds a reference to const on top of T as necessary. For example, 84013481Sgiacomo.travaglini@arm.com// it transforms 84113481Sgiacomo.travaglini@arm.com// 84213481Sgiacomo.travaglini@arm.com// char ==> const char& 84313481Sgiacomo.travaglini@arm.com// const char ==> const char& 84413481Sgiacomo.travaglini@arm.com// char& ==> const char& 84513481Sgiacomo.travaglini@arm.com// const char& ==> const char& 84613481Sgiacomo.travaglini@arm.com// 84713481Sgiacomo.travaglini@arm.com// The argument T must depend on some template parameters. 84813481Sgiacomo.travaglini@arm.com#define GTEST_REFERENCE_TO_CONST_(T) \ 84913481Sgiacomo.travaglini@arm.com GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T)) 85013481Sgiacomo.travaglini@arm.com 85113481Sgiacomo.travaglini@arm.com// ImplicitlyConvertible<From, To>::value is a compile-time bool 85213481Sgiacomo.travaglini@arm.com// constant that's true iff type From can be implicitly converted to 85313481Sgiacomo.travaglini@arm.com// type To. 85413481Sgiacomo.travaglini@arm.comtemplate <typename From, typename To> 85513481Sgiacomo.travaglini@arm.comclass ImplicitlyConvertible { 85613481Sgiacomo.travaglini@arm.com private: 85713481Sgiacomo.travaglini@arm.com // We need the following helper functions only for their types. 85813481Sgiacomo.travaglini@arm.com // They have no implementations. 85913481Sgiacomo.travaglini@arm.com 86013481Sgiacomo.travaglini@arm.com // MakeFrom() is an expression whose type is From. We cannot simply 86113481Sgiacomo.travaglini@arm.com // use From(), as the type From may not have a public default 86213481Sgiacomo.travaglini@arm.com // constructor. 86313481Sgiacomo.travaglini@arm.com static typename AddReference<From>::type MakeFrom(); 86413481Sgiacomo.travaglini@arm.com 86513481Sgiacomo.travaglini@arm.com // These two functions are overloaded. Given an expression 86613481Sgiacomo.travaglini@arm.com // Helper(x), the compiler will pick the first version if x can be 86713481Sgiacomo.travaglini@arm.com // implicitly converted to type To; otherwise it will pick the 86813481Sgiacomo.travaglini@arm.com // second version. 86913481Sgiacomo.travaglini@arm.com // 87013481Sgiacomo.travaglini@arm.com // The first version returns a value of size 1, and the second 87113481Sgiacomo.travaglini@arm.com // version returns a value of size 2. Therefore, by checking the 87213481Sgiacomo.travaglini@arm.com // size of Helper(x), which can be done at compile time, we can tell 87313481Sgiacomo.travaglini@arm.com // which version of Helper() is used, and hence whether x can be 87413481Sgiacomo.travaglini@arm.com // implicitly converted to type To. 87513481Sgiacomo.travaglini@arm.com static char Helper(To); 87613481Sgiacomo.travaglini@arm.com static char (&Helper(...))[2]; // NOLINT 87713481Sgiacomo.travaglini@arm.com 87813481Sgiacomo.travaglini@arm.com // We have to put the 'public' section after the 'private' section, 87913481Sgiacomo.travaglini@arm.com // or MSVC refuses to compile the code. 88013481Sgiacomo.travaglini@arm.com public: 88113481Sgiacomo.travaglini@arm.com#if defined(__BORLANDC__) 88213481Sgiacomo.travaglini@arm.com // C++Builder cannot use member overload resolution during template 88313481Sgiacomo.travaglini@arm.com // instantiation. The simplest workaround is to use its C++0x type traits 88413481Sgiacomo.travaglini@arm.com // functions (C++Builder 2009 and above only). 88513481Sgiacomo.travaglini@arm.com static const bool value = __is_convertible(From, To); 88613481Sgiacomo.travaglini@arm.com#else 88713481Sgiacomo.travaglini@arm.com // MSVC warns about implicitly converting from double to int for 88813481Sgiacomo.travaglini@arm.com // possible loss of data, so we need to temporarily disable the 88913481Sgiacomo.travaglini@arm.com // warning. 89013481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244) 89113481Sgiacomo.travaglini@arm.com static const bool value = 89213481Sgiacomo.travaglini@arm.com sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; 89313481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_POP_() 89413481Sgiacomo.travaglini@arm.com#endif // __BORLANDC__ 89513481Sgiacomo.travaglini@arm.com}; 89613481Sgiacomo.travaglini@arm.comtemplate <typename From, typename To> 89713481Sgiacomo.travaglini@arm.comconst bool ImplicitlyConvertible<From, To>::value; 89813481Sgiacomo.travaglini@arm.com 89913481Sgiacomo.travaglini@arm.com// IsAProtocolMessage<T>::value is a compile-time bool constant that's 90013481Sgiacomo.travaglini@arm.com// true iff T is type ProtocolMessage, proto2::Message, or a subclass 90113481Sgiacomo.travaglini@arm.com// of those. 90213481Sgiacomo.travaglini@arm.comtemplate <typename T> 90313481Sgiacomo.travaglini@arm.comstruct IsAProtocolMessage 90413481Sgiacomo.travaglini@arm.com : public bool_constant< 90513481Sgiacomo.travaglini@arm.com ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value || 90613481Sgiacomo.travaglini@arm.com ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> { 90713481Sgiacomo.travaglini@arm.com}; 90813481Sgiacomo.travaglini@arm.com 90913481Sgiacomo.travaglini@arm.com// When the compiler sees expression IsContainerTest<C>(0), if C is an 91013481Sgiacomo.travaglini@arm.com// STL-style container class, the first overload of IsContainerTest 91113481Sgiacomo.travaglini@arm.com// will be viable (since both C::iterator* and C::const_iterator* are 91213481Sgiacomo.travaglini@arm.com// valid types and NULL can be implicitly converted to them). It will 91313481Sgiacomo.travaglini@arm.com// be picked over the second overload as 'int' is a perfect match for 91413481Sgiacomo.travaglini@arm.com// the type of argument 0. If C::iterator or C::const_iterator is not 91513481Sgiacomo.travaglini@arm.com// a valid type, the first overload is not viable, and the second 91613481Sgiacomo.travaglini@arm.com// overload will be picked. Therefore, we can determine whether C is 91713481Sgiacomo.travaglini@arm.com// a container class by checking the type of IsContainerTest<C>(0). 91813481Sgiacomo.travaglini@arm.com// The value of the expression is insignificant. 91913481Sgiacomo.travaglini@arm.com// 92013481Sgiacomo.travaglini@arm.com// Note that we look for both C::iterator and C::const_iterator. The 92113481Sgiacomo.travaglini@arm.com// reason is that C++ injects the name of a class as a member of the 92213481Sgiacomo.travaglini@arm.com// class itself (e.g. you can refer to class iterator as either 92313481Sgiacomo.travaglini@arm.com// 'iterator' or 'iterator::iterator'). If we look for C::iterator 92413481Sgiacomo.travaglini@arm.com// only, for example, we would mistakenly think that a class named 92513481Sgiacomo.travaglini@arm.com// iterator is an STL container. 92613481Sgiacomo.travaglini@arm.com// 92713481Sgiacomo.travaglini@arm.com// Also note that the simpler approach of overloading 92813481Sgiacomo.travaglini@arm.com// IsContainerTest(typename C::const_iterator*) and 92913481Sgiacomo.travaglini@arm.com// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. 93013481Sgiacomo.travaglini@arm.comtypedef int IsContainer; 93113481Sgiacomo.travaglini@arm.comtemplate <class C> 93213481Sgiacomo.travaglini@arm.comIsContainer IsContainerTest(int /* dummy */, 93313481Sgiacomo.travaglini@arm.com typename C::iterator* /* it */ = NULL, 93413481Sgiacomo.travaglini@arm.com typename C::const_iterator* /* const_it */ = NULL) { 93513481Sgiacomo.travaglini@arm.com return 0; 93613481Sgiacomo.travaglini@arm.com} 93713481Sgiacomo.travaglini@arm.com 93813481Sgiacomo.travaglini@arm.comtypedef char IsNotContainer; 93913481Sgiacomo.travaglini@arm.comtemplate <class C> 94013481Sgiacomo.travaglini@arm.comIsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } 94113481Sgiacomo.travaglini@arm.com 94213481Sgiacomo.travaglini@arm.com// EnableIf<condition>::type is void when 'Cond' is true, and 94313481Sgiacomo.travaglini@arm.com// undefined when 'Cond' is false. To use SFINAE to make a function 94413481Sgiacomo.travaglini@arm.com// overload only apply when a particular expression is true, add 94513481Sgiacomo.travaglini@arm.com// "typename EnableIf<expression>::type* = 0" as the last parameter. 94613481Sgiacomo.travaglini@arm.comtemplate<bool> struct EnableIf; 94713481Sgiacomo.travaglini@arm.comtemplate<> struct EnableIf<true> { typedef void type; }; // NOLINT 94813481Sgiacomo.travaglini@arm.com 94913481Sgiacomo.travaglini@arm.com// Utilities for native arrays. 95013481Sgiacomo.travaglini@arm.com 95113481Sgiacomo.travaglini@arm.com// ArrayEq() compares two k-dimensional native arrays using the 95213481Sgiacomo.travaglini@arm.com// elements' operator==, where k can be any integer >= 0. When k is 95313481Sgiacomo.travaglini@arm.com// 0, ArrayEq() degenerates into comparing a single pair of values. 95413481Sgiacomo.travaglini@arm.com 95513481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U> 95613481Sgiacomo.travaglini@arm.combool ArrayEq(const T* lhs, size_t size, const U* rhs); 95713481Sgiacomo.travaglini@arm.com 95813481Sgiacomo.travaglini@arm.com// This generic version is used when k is 0. 95913481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U> 96013481Sgiacomo.travaglini@arm.cominline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } 96113481Sgiacomo.travaglini@arm.com 96213481Sgiacomo.travaglini@arm.com// This overload is used when k >= 1. 96313481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U, size_t N> 96413481Sgiacomo.travaglini@arm.cominline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { 96513481Sgiacomo.travaglini@arm.com return internal::ArrayEq(lhs, N, rhs); 96613481Sgiacomo.travaglini@arm.com} 96713481Sgiacomo.travaglini@arm.com 96813481Sgiacomo.travaglini@arm.com// This helper reduces code bloat. If we instead put its logic inside 96913481Sgiacomo.travaglini@arm.com// the previous ArrayEq() function, arrays with different sizes would 97013481Sgiacomo.travaglini@arm.com// lead to different copies of the template code. 97113481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U> 97213481Sgiacomo.travaglini@arm.combool ArrayEq(const T* lhs, size_t size, const U* rhs) { 97313481Sgiacomo.travaglini@arm.com for (size_t i = 0; i != size; i++) { 97413481Sgiacomo.travaglini@arm.com if (!internal::ArrayEq(lhs[i], rhs[i])) 97513481Sgiacomo.travaglini@arm.com return false; 97613481Sgiacomo.travaglini@arm.com } 97713481Sgiacomo.travaglini@arm.com return true; 97813481Sgiacomo.travaglini@arm.com} 97913481Sgiacomo.travaglini@arm.com 98013481Sgiacomo.travaglini@arm.com// Finds the first element in the iterator range [begin, end) that 98113481Sgiacomo.travaglini@arm.com// equals elem. Element may be a native array type itself. 98213481Sgiacomo.travaglini@arm.comtemplate <typename Iter, typename Element> 98313481Sgiacomo.travaglini@arm.comIter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { 98413481Sgiacomo.travaglini@arm.com for (Iter it = begin; it != end; ++it) { 98513481Sgiacomo.travaglini@arm.com if (internal::ArrayEq(*it, elem)) 98613481Sgiacomo.travaglini@arm.com return it; 98713481Sgiacomo.travaglini@arm.com } 98813481Sgiacomo.travaglini@arm.com return end; 98913481Sgiacomo.travaglini@arm.com} 99013481Sgiacomo.travaglini@arm.com 99113481Sgiacomo.travaglini@arm.com// CopyArray() copies a k-dimensional native array using the elements' 99213481Sgiacomo.travaglini@arm.com// operator=, where k can be any integer >= 0. When k is 0, 99313481Sgiacomo.travaglini@arm.com// CopyArray() degenerates into copying a single value. 99413481Sgiacomo.travaglini@arm.com 99513481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U> 99613481Sgiacomo.travaglini@arm.comvoid CopyArray(const T* from, size_t size, U* to); 99713481Sgiacomo.travaglini@arm.com 99813481Sgiacomo.travaglini@arm.com// This generic version is used when k is 0. 99913481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U> 100013481Sgiacomo.travaglini@arm.cominline void CopyArray(const T& from, U* to) { *to = from; } 100113481Sgiacomo.travaglini@arm.com 100213481Sgiacomo.travaglini@arm.com// This overload is used when k >= 1. 100313481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U, size_t N> 100413481Sgiacomo.travaglini@arm.cominline void CopyArray(const T(&from)[N], U(*to)[N]) { 100513481Sgiacomo.travaglini@arm.com internal::CopyArray(from, N, *to); 100613481Sgiacomo.travaglini@arm.com} 100713481Sgiacomo.travaglini@arm.com 100813481Sgiacomo.travaglini@arm.com// This helper reduces code bloat. If we instead put its logic inside 100913481Sgiacomo.travaglini@arm.com// the previous CopyArray() function, arrays with different sizes 101013481Sgiacomo.travaglini@arm.com// would lead to different copies of the template code. 101113481Sgiacomo.travaglini@arm.comtemplate <typename T, typename U> 101213481Sgiacomo.travaglini@arm.comvoid CopyArray(const T* from, size_t size, U* to) { 101313481Sgiacomo.travaglini@arm.com for (size_t i = 0; i != size; i++) { 101413481Sgiacomo.travaglini@arm.com internal::CopyArray(from[i], to + i); 101513481Sgiacomo.travaglini@arm.com } 101613481Sgiacomo.travaglini@arm.com} 101713481Sgiacomo.travaglini@arm.com 101813481Sgiacomo.travaglini@arm.com// The relation between an NativeArray object (see below) and the 101913481Sgiacomo.travaglini@arm.com// native array it represents. 102013481Sgiacomo.travaglini@arm.com// We use 2 different structs to allow non-copyable types to be used, as long 102113481Sgiacomo.travaglini@arm.com// as RelationToSourceReference() is passed. 102213481Sgiacomo.travaglini@arm.comstruct RelationToSourceReference {}; 102313481Sgiacomo.travaglini@arm.comstruct RelationToSourceCopy {}; 102413481Sgiacomo.travaglini@arm.com 102513481Sgiacomo.travaglini@arm.com// Adapts a native array to a read-only STL-style container. Instead 102613481Sgiacomo.travaglini@arm.com// of the complete STL container concept, this adaptor only implements 102713481Sgiacomo.travaglini@arm.com// members useful for Google Mock's container matchers. New members 102813481Sgiacomo.travaglini@arm.com// should be added as needed. To simplify the implementation, we only 102913481Sgiacomo.travaglini@arm.com// support Element being a raw type (i.e. having no top-level const or 103013481Sgiacomo.travaglini@arm.com// reference modifier). It's the client's responsibility to satisfy 103113481Sgiacomo.travaglini@arm.com// this requirement. Element can be an array type itself (hence 103213481Sgiacomo.travaglini@arm.com// multi-dimensional arrays are supported). 103313481Sgiacomo.travaglini@arm.comtemplate <typename Element> 103413481Sgiacomo.travaglini@arm.comclass NativeArray { 103513481Sgiacomo.travaglini@arm.com public: 103613481Sgiacomo.travaglini@arm.com // STL-style container typedefs. 103713481Sgiacomo.travaglini@arm.com typedef Element value_type; 103813481Sgiacomo.travaglini@arm.com typedef Element* iterator; 103913481Sgiacomo.travaglini@arm.com typedef const Element* const_iterator; 104013481Sgiacomo.travaglini@arm.com 104113481Sgiacomo.travaglini@arm.com // Constructs from a native array. References the source. 104213481Sgiacomo.travaglini@arm.com NativeArray(const Element* array, size_t count, RelationToSourceReference) { 104313481Sgiacomo.travaglini@arm.com InitRef(array, count); 104413481Sgiacomo.travaglini@arm.com } 104513481Sgiacomo.travaglini@arm.com 104613481Sgiacomo.travaglini@arm.com // Constructs from a native array. Copies the source. 104713481Sgiacomo.travaglini@arm.com NativeArray(const Element* array, size_t count, RelationToSourceCopy) { 104813481Sgiacomo.travaglini@arm.com InitCopy(array, count); 104913481Sgiacomo.travaglini@arm.com } 105013481Sgiacomo.travaglini@arm.com 105113481Sgiacomo.travaglini@arm.com // Copy constructor. 105213481Sgiacomo.travaglini@arm.com NativeArray(const NativeArray& rhs) { 105313481Sgiacomo.travaglini@arm.com (this->*rhs.clone_)(rhs.array_, rhs.size_); 105413481Sgiacomo.travaglini@arm.com } 105513481Sgiacomo.travaglini@arm.com 105613481Sgiacomo.travaglini@arm.com ~NativeArray() { 105713481Sgiacomo.travaglini@arm.com if (clone_ != &NativeArray::InitRef) 105813481Sgiacomo.travaglini@arm.com delete[] array_; 105913481Sgiacomo.travaglini@arm.com } 106013481Sgiacomo.travaglini@arm.com 106113481Sgiacomo.travaglini@arm.com // STL-style container methods. 106213481Sgiacomo.travaglini@arm.com size_t size() const { return size_; } 106313481Sgiacomo.travaglini@arm.com const_iterator begin() const { return array_; } 106413481Sgiacomo.travaglini@arm.com const_iterator end() const { return array_ + size_; } 106513481Sgiacomo.travaglini@arm.com bool operator==(const NativeArray& rhs) const { 106613481Sgiacomo.travaglini@arm.com return size() == rhs.size() && 106713481Sgiacomo.travaglini@arm.com ArrayEq(begin(), size(), rhs.begin()); 106813481Sgiacomo.travaglini@arm.com } 106913481Sgiacomo.travaglini@arm.com 107013481Sgiacomo.travaglini@arm.com private: 107113481Sgiacomo.travaglini@arm.com enum { 107213481Sgiacomo.travaglini@arm.com kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper< 107313481Sgiacomo.travaglini@arm.com Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value, 107413481Sgiacomo.travaglini@arm.com }; 107513481Sgiacomo.travaglini@arm.com 107613481Sgiacomo.travaglini@arm.com // Initializes this object with a copy of the input. 107713481Sgiacomo.travaglini@arm.com void InitCopy(const Element* array, size_t a_size) { 107813481Sgiacomo.travaglini@arm.com Element* const copy = new Element[a_size]; 107913481Sgiacomo.travaglini@arm.com CopyArray(array, a_size, copy); 108013481Sgiacomo.travaglini@arm.com array_ = copy; 108113481Sgiacomo.travaglini@arm.com size_ = a_size; 108213481Sgiacomo.travaglini@arm.com clone_ = &NativeArray::InitCopy; 108313481Sgiacomo.travaglini@arm.com } 108413481Sgiacomo.travaglini@arm.com 108513481Sgiacomo.travaglini@arm.com // Initializes this object with a reference of the input. 108613481Sgiacomo.travaglini@arm.com void InitRef(const Element* array, size_t a_size) { 108713481Sgiacomo.travaglini@arm.com array_ = array; 108813481Sgiacomo.travaglini@arm.com size_ = a_size; 108913481Sgiacomo.travaglini@arm.com clone_ = &NativeArray::InitRef; 109013481Sgiacomo.travaglini@arm.com } 109113481Sgiacomo.travaglini@arm.com 109213481Sgiacomo.travaglini@arm.com const Element* array_; 109313481Sgiacomo.travaglini@arm.com size_t size_; 109413481Sgiacomo.travaglini@arm.com void (NativeArray::*clone_)(const Element*, size_t); 109513481Sgiacomo.travaglini@arm.com 109613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(NativeArray); 109713481Sgiacomo.travaglini@arm.com}; 109813481Sgiacomo.travaglini@arm.com 109913481Sgiacomo.travaglini@arm.com} // namespace internal 110013481Sgiacomo.travaglini@arm.com} // namespace testing 110113481Sgiacomo.travaglini@arm.com 110213481Sgiacomo.travaglini@arm.com#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ 110313481Sgiacomo.travaglini@arm.com ::testing::internal::AssertHelper(result_type, file, line, message) \ 110413481Sgiacomo.travaglini@arm.com = ::testing::Message() 110513481Sgiacomo.travaglini@arm.com 110613481Sgiacomo.travaglini@arm.com#define GTEST_MESSAGE_(message, result_type) \ 110713481Sgiacomo.travaglini@arm.com GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) 110813481Sgiacomo.travaglini@arm.com 110913481Sgiacomo.travaglini@arm.com#define GTEST_FATAL_FAILURE_(message) \ 111013481Sgiacomo.travaglini@arm.com return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) 111113481Sgiacomo.travaglini@arm.com 111213481Sgiacomo.travaglini@arm.com#define GTEST_NONFATAL_FAILURE_(message) \ 111313481Sgiacomo.travaglini@arm.com GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) 111413481Sgiacomo.travaglini@arm.com 111513481Sgiacomo.travaglini@arm.com#define GTEST_SUCCESS_(message) \ 111613481Sgiacomo.travaglini@arm.com GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) 111713481Sgiacomo.travaglini@arm.com 111813481Sgiacomo.travaglini@arm.com// Suppresses MSVC warnings 4072 (unreachable code) for the code following 111913481Sgiacomo.travaglini@arm.com// statement if it returns or throws (or doesn't return or throw in some 112013481Sgiacomo.travaglini@arm.com// situations). 112113481Sgiacomo.travaglini@arm.com#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ 112213481Sgiacomo.travaglini@arm.com if (::testing::internal::AlwaysTrue()) { statement; } 112313481Sgiacomo.travaglini@arm.com 112413481Sgiacomo.travaglini@arm.com#define GTEST_TEST_THROW_(statement, expected_exception, fail) \ 112513481Sgiacomo.travaglini@arm.com GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 112613481Sgiacomo.travaglini@arm.com if (::testing::internal::ConstCharPtr gtest_msg = "") { \ 112713481Sgiacomo.travaglini@arm.com bool gtest_caught_expected = false; \ 112813481Sgiacomo.travaglini@arm.com try { \ 112913481Sgiacomo.travaglini@arm.com GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 113013481Sgiacomo.travaglini@arm.com } \ 113113481Sgiacomo.travaglini@arm.com catch (expected_exception const&) { \ 113213481Sgiacomo.travaglini@arm.com gtest_caught_expected = true; \ 113313481Sgiacomo.travaglini@arm.com } \ 113413481Sgiacomo.travaglini@arm.com catch (...) { \ 113513481Sgiacomo.travaglini@arm.com gtest_msg.value = \ 113613481Sgiacomo.travaglini@arm.com "Expected: " #statement " throws an exception of type " \ 113713481Sgiacomo.travaglini@arm.com #expected_exception ".\n Actual: it throws a different type."; \ 113813481Sgiacomo.travaglini@arm.com goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ 113913481Sgiacomo.travaglini@arm.com } \ 114013481Sgiacomo.travaglini@arm.com if (!gtest_caught_expected) { \ 114113481Sgiacomo.travaglini@arm.com gtest_msg.value = \ 114213481Sgiacomo.travaglini@arm.com "Expected: " #statement " throws an exception of type " \ 114313481Sgiacomo.travaglini@arm.com #expected_exception ".\n Actual: it throws nothing."; \ 114413481Sgiacomo.travaglini@arm.com goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ 114513481Sgiacomo.travaglini@arm.com } \ 114613481Sgiacomo.travaglini@arm.com } else \ 114713481Sgiacomo.travaglini@arm.com GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \ 114813481Sgiacomo.travaglini@arm.com fail(gtest_msg.value) 114913481Sgiacomo.travaglini@arm.com 115013481Sgiacomo.travaglini@arm.com#define GTEST_TEST_NO_THROW_(statement, fail) \ 115113481Sgiacomo.travaglini@arm.com GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 115213481Sgiacomo.travaglini@arm.com if (::testing::internal::AlwaysTrue()) { \ 115313481Sgiacomo.travaglini@arm.com try { \ 115413481Sgiacomo.travaglini@arm.com GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 115513481Sgiacomo.travaglini@arm.com } \ 115613481Sgiacomo.travaglini@arm.com catch (...) { \ 115713481Sgiacomo.travaglini@arm.com goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ 115813481Sgiacomo.travaglini@arm.com } \ 115913481Sgiacomo.travaglini@arm.com } else \ 116013481Sgiacomo.travaglini@arm.com GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ 116113481Sgiacomo.travaglini@arm.com fail("Expected: " #statement " doesn't throw an exception.\n" \ 116213481Sgiacomo.travaglini@arm.com " Actual: it throws.") 116313481Sgiacomo.travaglini@arm.com 116413481Sgiacomo.travaglini@arm.com#define GTEST_TEST_ANY_THROW_(statement, fail) \ 116513481Sgiacomo.travaglini@arm.com GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 116613481Sgiacomo.travaglini@arm.com if (::testing::internal::AlwaysTrue()) { \ 116713481Sgiacomo.travaglini@arm.com bool gtest_caught_any = false; \ 116813481Sgiacomo.travaglini@arm.com try { \ 116913481Sgiacomo.travaglini@arm.com GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 117013481Sgiacomo.travaglini@arm.com } \ 117113481Sgiacomo.travaglini@arm.com catch (...) { \ 117213481Sgiacomo.travaglini@arm.com gtest_caught_any = true; \ 117313481Sgiacomo.travaglini@arm.com } \ 117413481Sgiacomo.travaglini@arm.com if (!gtest_caught_any) { \ 117513481Sgiacomo.travaglini@arm.com goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ 117613481Sgiacomo.travaglini@arm.com } \ 117713481Sgiacomo.travaglini@arm.com } else \ 117813481Sgiacomo.travaglini@arm.com GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ 117913481Sgiacomo.travaglini@arm.com fail("Expected: " #statement " throws an exception.\n" \ 118013481Sgiacomo.travaglini@arm.com " Actual: it doesn't.") 118113481Sgiacomo.travaglini@arm.com 118213481Sgiacomo.travaglini@arm.com 118313481Sgiacomo.travaglini@arm.com// Implements Boolean test assertions such as EXPECT_TRUE. expression can be 118413481Sgiacomo.travaglini@arm.com// either a boolean expression or an AssertionResult. text is a textual 118513481Sgiacomo.travaglini@arm.com// represenation of expression as it was passed into the EXPECT_TRUE. 118613481Sgiacomo.travaglini@arm.com#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ 118713481Sgiacomo.travaglini@arm.com GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 118813481Sgiacomo.travaglini@arm.com if (const ::testing::AssertionResult gtest_ar_ = \ 118913481Sgiacomo.travaglini@arm.com ::testing::AssertionResult(expression)) \ 119013481Sgiacomo.travaglini@arm.com ; \ 119113481Sgiacomo.travaglini@arm.com else \ 119213481Sgiacomo.travaglini@arm.com fail(::testing::internal::GetBoolAssertionFailureMessage(\ 119313481Sgiacomo.travaglini@arm.com gtest_ar_, text, #actual, #expected).c_str()) 119413481Sgiacomo.travaglini@arm.com 119513481Sgiacomo.travaglini@arm.com#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ 119613481Sgiacomo.travaglini@arm.com GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 119713481Sgiacomo.travaglini@arm.com if (::testing::internal::AlwaysTrue()) { \ 119813481Sgiacomo.travaglini@arm.com ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ 119913481Sgiacomo.travaglini@arm.com GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 120013481Sgiacomo.travaglini@arm.com if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ 120113481Sgiacomo.travaglini@arm.com goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ 120213481Sgiacomo.travaglini@arm.com } \ 120313481Sgiacomo.travaglini@arm.com } else \ 120413481Sgiacomo.travaglini@arm.com GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ 120513481Sgiacomo.travaglini@arm.com fail("Expected: " #statement " doesn't generate new fatal " \ 120613481Sgiacomo.travaglini@arm.com "failures in the current thread.\n" \ 120713481Sgiacomo.travaglini@arm.com " Actual: it does.") 120813481Sgiacomo.travaglini@arm.com 120913481Sgiacomo.travaglini@arm.com// Expands to the name of the class that implements the given test. 121013481Sgiacomo.travaglini@arm.com#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ 121113481Sgiacomo.travaglini@arm.com test_case_name##_##test_name##_Test 121213481Sgiacomo.travaglini@arm.com 121313481Sgiacomo.travaglini@arm.com// Helper macro for defining tests. 121413481Sgiacomo.travaglini@arm.com#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\ 121513481Sgiacomo.travaglini@arm.comclass GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\ 121613481Sgiacomo.travaglini@arm.com public:\ 121713481Sgiacomo.travaglini@arm.com GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\ 121813481Sgiacomo.travaglini@arm.com private:\ 121913481Sgiacomo.travaglini@arm.com virtual void TestBody();\ 122013481Sgiacomo.travaglini@arm.com static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\ 122113481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(\ 122213481Sgiacomo.travaglini@arm.com GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ 122313481Sgiacomo.travaglini@arm.com};\ 122413481Sgiacomo.travaglini@arm.com\ 122513481Sgiacomo.travaglini@arm.com::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ 122613481Sgiacomo.travaglini@arm.com ::test_info_ =\ 122713481Sgiacomo.travaglini@arm.com ::testing::internal::MakeAndRegisterTestInfo(\ 122813481Sgiacomo.travaglini@arm.com #test_case_name, #test_name, NULL, NULL, \ 122913481Sgiacomo.travaglini@arm.com ::testing::internal::CodeLocation(__FILE__, __LINE__), \ 123013481Sgiacomo.travaglini@arm.com (parent_id), \ 123113481Sgiacomo.travaglini@arm.com parent_class::SetUpTestCase, \ 123213481Sgiacomo.travaglini@arm.com parent_class::TearDownTestCase, \ 123313481Sgiacomo.travaglini@arm.com new ::testing::internal::TestFactoryImpl<\ 123413481Sgiacomo.travaglini@arm.com GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\ 123513481Sgiacomo.travaglini@arm.comvoid GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() 123613481Sgiacomo.travaglini@arm.com 123713481Sgiacomo.travaglini@arm.com#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 123813481Sgiacomo.travaglini@arm.com 1239