gmock-internal-utils.h revision 13481
1// Copyright 2007, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29// 30// Author: wan@google.com (Zhanyong Wan) 31 32// Google Mock - a framework for writing C++ mock classes. 33// 34// This file defines some utilities useful for implementing Google 35// Mock. They are subject to change without notice, so please DO NOT 36// USE THEM IN USER CODE. 37 38#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ 39#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ 40 41#include <stdio.h> 42#include <ostream> // NOLINT 43#include <string> 44 45#include "gmock/internal/gmock-generated-internal-utils.h" 46#include "gmock/internal/gmock-port.h" 47#include "gtest/gtest.h" 48 49namespace testing { 50namespace internal { 51 52// Converts an identifier name to a space-separated list of lower-case 53// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is 54// treated as one word. For example, both "FooBar123" and 55// "foo_bar_123" are converted to "foo bar 123". 56GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name); 57 58// PointeeOf<Pointer>::type is the type of a value pointed to by a 59// Pointer, which can be either a smart pointer or a raw pointer. The 60// following default implementation is for the case where Pointer is a 61// smart pointer. 62template <typename Pointer> 63struct PointeeOf { 64 // Smart pointer classes define type element_type as the type of 65 // their pointees. 66 typedef typename Pointer::element_type type; 67}; 68// This specialization is for the raw pointer case. 69template <typename T> 70struct PointeeOf<T*> { typedef T type; }; // NOLINT 71 72// GetRawPointer(p) returns the raw pointer underlying p when p is a 73// smart pointer, or returns p itself when p is already a raw pointer. 74// The following default implementation is for the smart pointer case. 75template <typename Pointer> 76inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) { 77 return p.get(); 78} 79// This overloaded version is for the raw pointer case. 80template <typename Element> 81inline Element* GetRawPointer(Element* p) { return p; } 82 83// This comparator allows linked_ptr to be stored in sets. 84template <typename T> 85struct LinkedPtrLessThan { 86 bool operator()(const ::testing::internal::linked_ptr<T>& lhs, 87 const ::testing::internal::linked_ptr<T>& rhs) const { 88 return lhs.get() < rhs.get(); 89 } 90}; 91 92// Symbian compilation can be done with wchar_t being either a native 93// type or a typedef. Using Google Mock with OpenC without wchar_t 94// should require the definition of _STLP_NO_WCHAR_T. 95// 96// MSVC treats wchar_t as a native type usually, but treats it as the 97// same as unsigned short when the compiler option /Zc:wchar_t- is 98// specified. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t 99// is a native type. 100#if (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \ 101 (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)) 102// wchar_t is a typedef. 103#else 104# define GMOCK_WCHAR_T_IS_NATIVE_ 1 105#endif 106 107// signed wchar_t and unsigned wchar_t are NOT in the C++ standard. 108// Using them is a bad practice and not portable. So DON'T use them. 109// 110// Still, Google Mock is designed to work even if the user uses signed 111// wchar_t or unsigned wchar_t (obviously, assuming the compiler 112// supports them). 113// 114// To gcc, 115// wchar_t == signed wchar_t != unsigned wchar_t == unsigned int 116#ifdef __GNUC__ 117// signed/unsigned wchar_t are valid types. 118# define GMOCK_HAS_SIGNED_WCHAR_T_ 1 119#endif 120 121// In what follows, we use the term "kind" to indicate whether a type 122// is bool, an integer type (excluding bool), a floating-point type, 123// or none of them. This categorization is useful for determining 124// when a matcher argument type can be safely converted to another 125// type in the implementation of SafeMatcherCast. 126enum TypeKind { 127 kBool, kInteger, kFloatingPoint, kOther 128}; 129 130// KindOf<T>::value is the kind of type T. 131template <typename T> struct KindOf { 132 enum { value = kOther }; // The default kind. 133}; 134 135// This macro declares that the kind of 'type' is 'kind'. 136#define GMOCK_DECLARE_KIND_(type, kind) \ 137 template <> struct KindOf<type> { enum { value = kind }; } 138 139GMOCK_DECLARE_KIND_(bool, kBool); 140 141// All standard integer types. 142GMOCK_DECLARE_KIND_(char, kInteger); 143GMOCK_DECLARE_KIND_(signed char, kInteger); 144GMOCK_DECLARE_KIND_(unsigned char, kInteger); 145GMOCK_DECLARE_KIND_(short, kInteger); // NOLINT 146GMOCK_DECLARE_KIND_(unsigned short, kInteger); // NOLINT 147GMOCK_DECLARE_KIND_(int, kInteger); 148GMOCK_DECLARE_KIND_(unsigned int, kInteger); 149GMOCK_DECLARE_KIND_(long, kInteger); // NOLINT 150GMOCK_DECLARE_KIND_(unsigned long, kInteger); // NOLINT 151 152#if GMOCK_WCHAR_T_IS_NATIVE_ 153GMOCK_DECLARE_KIND_(wchar_t, kInteger); 154#endif 155 156// Non-standard integer types. 157GMOCK_DECLARE_KIND_(Int64, kInteger); 158GMOCK_DECLARE_KIND_(UInt64, kInteger); 159 160// All standard floating-point types. 161GMOCK_DECLARE_KIND_(float, kFloatingPoint); 162GMOCK_DECLARE_KIND_(double, kFloatingPoint); 163GMOCK_DECLARE_KIND_(long double, kFloatingPoint); 164 165#undef GMOCK_DECLARE_KIND_ 166 167// Evaluates to the kind of 'type'. 168#define GMOCK_KIND_OF_(type) \ 169 static_cast< ::testing::internal::TypeKind>( \ 170 ::testing::internal::KindOf<type>::value) 171 172// Evaluates to true iff integer type T is signed. 173#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0) 174 175// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value 176// is true iff arithmetic type From can be losslessly converted to 177// arithmetic type To. 178// 179// It's the user's responsibility to ensure that both From and To are 180// raw (i.e. has no CV modifier, is not a pointer, and is not a 181// reference) built-in arithmetic types, kFromKind is the kind of 182// From, and kToKind is the kind of To; the value is 183// implementation-defined when the above pre-condition is violated. 184template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To> 185struct LosslessArithmeticConvertibleImpl : public false_type {}; 186 187// Converting bool to bool is lossless. 188template <> 189struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool> 190 : public true_type {}; // NOLINT 191 192// Converting bool to any integer type is lossless. 193template <typename To> 194struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To> 195 : public true_type {}; // NOLINT 196 197// Converting bool to any floating-point type is lossless. 198template <typename To> 199struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To> 200 : public true_type {}; // NOLINT 201 202// Converting an integer to bool is lossy. 203template <typename From> 204struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool> 205 : public false_type {}; // NOLINT 206 207// Converting an integer to another non-bool integer is lossless iff 208// the target type's range encloses the source type's range. 209template <typename From, typename To> 210struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To> 211 : public bool_constant< 212 // When converting from a smaller size to a larger size, we are 213 // fine as long as we are not converting from signed to unsigned. 214 ((sizeof(From) < sizeof(To)) && 215 (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) || 216 // When converting between the same size, the signedness must match. 217 ((sizeof(From) == sizeof(To)) && 218 (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {}; // NOLINT 219 220#undef GMOCK_IS_SIGNED_ 221 222// Converting an integer to a floating-point type may be lossy, since 223// the format of a floating-point number is implementation-defined. 224template <typename From, typename To> 225struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To> 226 : public false_type {}; // NOLINT 227 228// Converting a floating-point to bool is lossy. 229template <typename From> 230struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool> 231 : public false_type {}; // NOLINT 232 233// Converting a floating-point to an integer is lossy. 234template <typename From, typename To> 235struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To> 236 : public false_type {}; // NOLINT 237 238// Converting a floating-point to another floating-point is lossless 239// iff the target type is at least as big as the source type. 240template <typename From, typename To> 241struct LosslessArithmeticConvertibleImpl< 242 kFloatingPoint, From, kFloatingPoint, To> 243 : public bool_constant<sizeof(From) <= sizeof(To)> {}; // NOLINT 244 245// LosslessArithmeticConvertible<From, To>::value is true iff arithmetic 246// type From can be losslessly converted to arithmetic type To. 247// 248// It's the user's responsibility to ensure that both From and To are 249// raw (i.e. has no CV modifier, is not a pointer, and is not a 250// reference) built-in arithmetic types; the value is 251// implementation-defined when the above pre-condition is violated. 252template <typename From, typename To> 253struct LosslessArithmeticConvertible 254 : public LosslessArithmeticConvertibleImpl< 255 GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {}; // NOLINT 256 257// This interface knows how to report a Google Mock failure (either 258// non-fatal or fatal). 259class FailureReporterInterface { 260 public: 261 // The type of a failure (either non-fatal or fatal). 262 enum FailureType { 263 kNonfatal, kFatal 264 }; 265 266 virtual ~FailureReporterInterface() {} 267 268 // Reports a failure that occurred at the given source file location. 269 virtual void ReportFailure(FailureType type, const char* file, int line, 270 const string& message) = 0; 271}; 272 273// Returns the failure reporter used by Google Mock. 274GTEST_API_ FailureReporterInterface* GetFailureReporter(); 275 276// Asserts that condition is true; aborts the process with the given 277// message if condition is false. We cannot use LOG(FATAL) or CHECK() 278// as Google Mock might be used to mock the log sink itself. We 279// inline this function to prevent it from showing up in the stack 280// trace. 281inline void Assert(bool condition, const char* file, int line, 282 const string& msg) { 283 if (!condition) { 284 GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal, 285 file, line, msg); 286 } 287} 288inline void Assert(bool condition, const char* file, int line) { 289 Assert(condition, file, line, "Assertion failed."); 290} 291 292// Verifies that condition is true; generates a non-fatal failure if 293// condition is false. 294inline void Expect(bool condition, const char* file, int line, 295 const string& msg) { 296 if (!condition) { 297 GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal, 298 file, line, msg); 299 } 300} 301inline void Expect(bool condition, const char* file, int line) { 302 Expect(condition, file, line, "Expectation failed."); 303} 304 305// Severity level of a log. 306enum LogSeverity { 307 kInfo = 0, 308 kWarning = 1 309}; 310 311// Valid values for the --gmock_verbose flag. 312 313// All logs (informational and warnings) are printed. 314const char kInfoVerbosity[] = "info"; 315// Only warnings are printed. 316const char kWarningVerbosity[] = "warning"; 317// No logs are printed. 318const char kErrorVerbosity[] = "error"; 319 320// Returns true iff a log with the given severity is visible according 321// to the --gmock_verbose flag. 322GTEST_API_ bool LogIsVisible(LogSeverity severity); 323 324// Prints the given message to stdout iff 'severity' >= the level 325// specified by the --gmock_verbose flag. If stack_frames_to_skip >= 326// 0, also prints the stack trace excluding the top 327// stack_frames_to_skip frames. In opt mode, any positive 328// stack_frames_to_skip is treated as 0, since we don't know which 329// function calls will be inlined by the compiler and need to be 330// conservative. 331GTEST_API_ void Log(LogSeverity severity, 332 const string& message, 333 int stack_frames_to_skip); 334 335// TODO(wan@google.com): group all type utilities together. 336 337// Type traits. 338 339// is_reference<T>::value is non-zero iff T is a reference type. 340template <typename T> struct is_reference : public false_type {}; 341template <typename T> struct is_reference<T&> : public true_type {}; 342 343// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type. 344template <typename T1, typename T2> struct type_equals : public false_type {}; 345template <typename T> struct type_equals<T, T> : public true_type {}; 346 347// remove_reference<T>::type removes the reference from type T, if any. 348template <typename T> struct remove_reference { typedef T type; }; // NOLINT 349template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT 350 351// DecayArray<T>::type turns an array type U[N] to const U* and preserves 352// other types. Useful for saving a copy of a function argument. 353template <typename T> struct DecayArray { typedef T type; }; // NOLINT 354template <typename T, size_t N> struct DecayArray<T[N]> { 355 typedef const T* type; 356}; 357// Sometimes people use arrays whose size is not available at the use site 358// (e.g. extern const char kNamePrefix[]). This specialization covers that 359// case. 360template <typename T> struct DecayArray<T[]> { 361 typedef const T* type; 362}; 363 364// Disable MSVC warnings for infinite recursion, since in this case the 365// the recursion is unreachable. 366#ifdef _MSC_VER 367# pragma warning(push) 368# pragma warning(disable:4717) 369#endif 370 371// Invalid<T>() is usable as an expression of type T, but will terminate 372// the program with an assertion failure if actually run. This is useful 373// when a value of type T is needed for compilation, but the statement 374// will not really be executed (or we don't care if the statement 375// crashes). 376template <typename T> 377inline T Invalid() { 378 Assert(false, "", -1, "Internal error: attempt to return invalid value"); 379 // This statement is unreachable, and would never terminate even if it 380 // could be reached. It is provided only to placate compiler warnings 381 // about missing return statements. 382 return Invalid<T>(); 383} 384 385#ifdef _MSC_VER 386# pragma warning(pop) 387#endif 388 389// Given a raw type (i.e. having no top-level reference or const 390// modifier) RawContainer that's either an STL-style container or a 391// native array, class StlContainerView<RawContainer> has the 392// following members: 393// 394// - type is a type that provides an STL-style container view to 395// (i.e. implements the STL container concept for) RawContainer; 396// - const_reference is a type that provides a reference to a const 397// RawContainer; 398// - ConstReference(raw_container) returns a const reference to an STL-style 399// container view to raw_container, which is a RawContainer. 400// - Copy(raw_container) returns an STL-style container view of a 401// copy of raw_container, which is a RawContainer. 402// 403// This generic version is used when RawContainer itself is already an 404// STL-style container. 405template <class RawContainer> 406class StlContainerView { 407 public: 408 typedef RawContainer type; 409 typedef const type& const_reference; 410 411 static const_reference ConstReference(const RawContainer& container) { 412 // Ensures that RawContainer is not a const type. 413 testing::StaticAssertTypeEq<RawContainer, 414 GTEST_REMOVE_CONST_(RawContainer)>(); 415 return container; 416 } 417 static type Copy(const RawContainer& container) { return container; } 418}; 419 420// This specialization is used when RawContainer is a native array type. 421template <typename Element, size_t N> 422class StlContainerView<Element[N]> { 423 public: 424 typedef GTEST_REMOVE_CONST_(Element) RawElement; 425 typedef internal::NativeArray<RawElement> type; 426 // NativeArray<T> can represent a native array either by value or by 427 // reference (selected by a constructor argument), so 'const type' 428 // can be used to reference a const native array. We cannot 429 // 'typedef const type& const_reference' here, as that would mean 430 // ConstReference() has to return a reference to a local variable. 431 typedef const type const_reference; 432 433 static const_reference ConstReference(const Element (&array)[N]) { 434 // Ensures that Element is not a const type. 435 testing::StaticAssertTypeEq<Element, RawElement>(); 436#if GTEST_OS_SYMBIAN 437 // The Nokia Symbian compiler confuses itself in template instantiation 438 // for this call without the cast to Element*: 439 // function call '[testing::internal::NativeArray<char *>].NativeArray( 440 // {lval} const char *[4], long, testing::internal::RelationToSource)' 441 // does not match 442 // 'testing::internal::NativeArray<char *>::NativeArray( 443 // char *const *, unsigned int, testing::internal::RelationToSource)' 444 // (instantiating: 'testing::internal::ContainsMatcherImpl 445 // <const char * (&)[4]>::Matches(const char * (&)[4]) const') 446 // (instantiating: 'testing::internal::StlContainerView<char *[4]>:: 447 // ConstReference(const char * (&)[4])') 448 // (and though the N parameter type is mismatched in the above explicit 449 // conversion of it doesn't help - only the conversion of the array). 450 return type(const_cast<Element*>(&array[0]), N, 451 RelationToSourceReference()); 452#else 453 return type(array, N, RelationToSourceReference()); 454#endif // GTEST_OS_SYMBIAN 455 } 456 static type Copy(const Element (&array)[N]) { 457#if GTEST_OS_SYMBIAN 458 return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy()); 459#else 460 return type(array, N, RelationToSourceCopy()); 461#endif // GTEST_OS_SYMBIAN 462 } 463}; 464 465// This specialization is used when RawContainer is a native array 466// represented as a (pointer, size) tuple. 467template <typename ElementPointer, typename Size> 468class StlContainerView< ::testing::tuple<ElementPointer, Size> > { 469 public: 470 typedef GTEST_REMOVE_CONST_( 471 typename internal::PointeeOf<ElementPointer>::type) RawElement; 472 typedef internal::NativeArray<RawElement> type; 473 typedef const type const_reference; 474 475 static const_reference ConstReference( 476 const ::testing::tuple<ElementPointer, Size>& array) { 477 return type(get<0>(array), get<1>(array), RelationToSourceReference()); 478 } 479 static type Copy(const ::testing::tuple<ElementPointer, Size>& array) { 480 return type(get<0>(array), get<1>(array), RelationToSourceCopy()); 481 } 482}; 483 484// The following specialization prevents the user from instantiating 485// StlContainer with a reference type. 486template <typename T> class StlContainerView<T&>; 487 488// A type transform to remove constness from the first part of a pair. 489// Pairs like that are used as the value_type of associative containers, 490// and this transform produces a similar but assignable pair. 491template <typename T> 492struct RemoveConstFromKey { 493 typedef T type; 494}; 495 496// Partially specialized to remove constness from std::pair<const K, V>. 497template <typename K, typename V> 498struct RemoveConstFromKey<std::pair<const K, V> > { 499 typedef std::pair<K, V> type; 500}; 501 502// Mapping from booleans to types. Similar to boost::bool_<kValue> and 503// std::integral_constant<bool, kValue>. 504template <bool kValue> 505struct BooleanConstant {}; 506 507} // namespace internal 508} // namespace testing 509 510#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ 511 512