[12177] | 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 | |
---|
| 49 | namespace testing { |
---|
| 50 | namespace 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". |
---|
| 56 | 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. |
---|
| 62 | template <typename Pointer> |
---|
| 63 | struct 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. |
---|
| 69 | template <typename T> |
---|
| 70 | struct 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. |
---|
| 75 | template <typename Pointer> |
---|
| 76 | inline typename Pointer::element_type* GetRawPointer(const Pointer& p) { |
---|
| 77 | return p.get(); |
---|
| 78 | } |
---|
| 79 | // This overloaded version is for the raw pointer case. |
---|
| 80 | template <typename Element> |
---|
| 81 | inline Element* GetRawPointer(Element* p) { return p; } |
---|
| 82 | |
---|
| 83 | // This comparator allows linked_ptr to be stored in sets. |
---|
| 84 | template <typename T> |
---|
| 85 | struct 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. |
---|
| 126 | enum TypeKind { |
---|
| 127 | kBool, kInteger, kFloatingPoint, kOther |
---|
| 128 | }; |
---|
| 129 | |
---|
| 130 | // KindOf<T>::value is the kind of type T. |
---|
| 131 | template <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 | |
---|
| 139 | GMOCK_DECLARE_KIND_(bool, kBool); |
---|
| 140 | |
---|
| 141 | // All standard integer types. |
---|
| 142 | GMOCK_DECLARE_KIND_(char, kInteger); |
---|
| 143 | GMOCK_DECLARE_KIND_(signed char, kInteger); |
---|
| 144 | GMOCK_DECLARE_KIND_(unsigned char, kInteger); |
---|
| 145 | GMOCK_DECLARE_KIND_(short, kInteger); // NOLINT |
---|
| 146 | GMOCK_DECLARE_KIND_(unsigned short, kInteger); // NOLINT |
---|
| 147 | GMOCK_DECLARE_KIND_(int, kInteger); |
---|
| 148 | GMOCK_DECLARE_KIND_(unsigned int, kInteger); |
---|
| 149 | GMOCK_DECLARE_KIND_(long, kInteger); // NOLINT |
---|
| 150 | GMOCK_DECLARE_KIND_(unsigned long, kInteger); // NOLINT |
---|
| 151 | |
---|
| 152 | #if GMOCK_WCHAR_T_IS_NATIVE_ |
---|
| 153 | GMOCK_DECLARE_KIND_(wchar_t, kInteger); |
---|
| 154 | #endif |
---|
| 155 | |
---|
| 156 | // Non-standard integer types. |
---|
| 157 | GMOCK_DECLARE_KIND_(Int64, kInteger); |
---|
| 158 | GMOCK_DECLARE_KIND_(UInt64, kInteger); |
---|
| 159 | |
---|
| 160 | // All standard floating-point types. |
---|
| 161 | GMOCK_DECLARE_KIND_(float, kFloatingPoint); |
---|
| 162 | GMOCK_DECLARE_KIND_(double, kFloatingPoint); |
---|
| 163 | GMOCK_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. |
---|
| 184 | template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To> |
---|
| 185 | struct LosslessArithmeticConvertibleImpl : public false_type {}; |
---|
| 186 | |
---|
| 187 | // Converting bool to bool is lossless. |
---|
| 188 | template <> |
---|
| 189 | struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool> |
---|
| 190 | : public true_type {}; // NOLINT |
---|
| 191 | |
---|
| 192 | // Converting bool to any integer type is lossless. |
---|
| 193 | template <typename To> |
---|
| 194 | struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To> |
---|
| 195 | : public true_type {}; // NOLINT |
---|
| 196 | |
---|
| 197 | // Converting bool to any floating-point type is lossless. |
---|
| 198 | template <typename To> |
---|
| 199 | struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To> |
---|
| 200 | : public true_type {}; // NOLINT |
---|
| 201 | |
---|
| 202 | // Converting an integer to bool is lossy. |
---|
| 203 | template <typename From> |
---|
| 204 | struct 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. |
---|
| 209 | template <typename From, typename To> |
---|
| 210 | struct 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. |
---|
| 224 | template <typename From, typename To> |
---|
| 225 | struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To> |
---|
| 226 | : public false_type {}; // NOLINT |
---|
| 227 | |
---|
| 228 | // Converting a floating-point to bool is lossy. |
---|
| 229 | template <typename From> |
---|
| 230 | struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool> |
---|
| 231 | : public false_type {}; // NOLINT |
---|
| 232 | |
---|
| 233 | // Converting a floating-point to an integer is lossy. |
---|
| 234 | template <typename From, typename To> |
---|
| 235 | struct 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. |
---|
| 240 | template <typename From, typename To> |
---|
| 241 | struct 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. |
---|
| 252 | template <typename From, typename To> |
---|
| 253 | struct 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). |
---|
| 259 | class FailureReporterInterface { |
---|
| 260 | public: |
---|
| 261 | // The type of a failure (either non-fatal or fatal). |
---|
| 262 | enum FailureType { |
---|
| 263 | NONFATAL, FATAL |
---|
| 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. |
---|
| 274 | 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. |
---|
| 281 | inline void Assert(bool condition, const char* file, int line, |
---|
| 282 | const string& msg) { |
---|
| 283 | if (!condition) { |
---|
| 284 | GetFailureReporter()->ReportFailure(FailureReporterInterface::FATAL, |
---|
| 285 | file, line, msg); |
---|
| 286 | } |
---|
| 287 | } |
---|
| 288 | inline 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. |
---|
| 294 | inline void Expect(bool condition, const char* file, int line, |
---|
| 295 | const string& msg) { |
---|
| 296 | if (!condition) { |
---|
| 297 | GetFailureReporter()->ReportFailure(FailureReporterInterface::NONFATAL, |
---|
| 298 | file, line, msg); |
---|
| 299 | } |
---|
| 300 | } |
---|
| 301 | inline void Expect(bool condition, const char* file, int line) { |
---|
| 302 | Expect(condition, file, line, "Expectation failed."); |
---|
| 303 | } |
---|
| 304 | |
---|
| 305 | // Severity level of a log. |
---|
| 306 | enum LogSeverity { |
---|
| 307 | INFO = 0, |
---|
| 308 | WARNING = 1 |
---|
| 309 | }; |
---|
| 310 | |
---|
| 311 | // Valid values for the --gmock_verbose flag. |
---|
| 312 | |
---|
| 313 | // All logs (informational and warnings) are printed. |
---|
| 314 | const char kInfoVerbosity[] = "info"; |
---|
| 315 | // Only warnings are printed. |
---|
| 316 | const char kWarningVerbosity[] = "warning"; |
---|
| 317 | // No logs are printed. |
---|
| 318 | const char kErrorVerbosity[] = "error"; |
---|
| 319 | |
---|
| 320 | // Returns true iff a log with the given severity is visible according |
---|
| 321 | // to the --gmock_verbose flag. |
---|
| 322 | 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. |
---|
| 331 | void Log(LogSeverity severity, const string& message, int stack_frames_to_skip); |
---|
| 332 | |
---|
| 333 | // TODO(wan@google.com): group all type utilities together. |
---|
| 334 | |
---|
| 335 | // Type traits. |
---|
| 336 | |
---|
| 337 | // is_reference<T>::value is non-zero iff T is a reference type. |
---|
| 338 | template <typename T> struct is_reference : public false_type {}; |
---|
| 339 | template <typename T> struct is_reference<T&> : public true_type {}; |
---|
| 340 | |
---|
| 341 | // type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type. |
---|
| 342 | template <typename T1, typename T2> struct type_equals : public false_type {}; |
---|
| 343 | template <typename T> struct type_equals<T, T> : public true_type {}; |
---|
| 344 | |
---|
| 345 | // remove_reference<T>::type removes the reference from type T, if any. |
---|
| 346 | template <typename T> struct remove_reference { typedef T type; }; // NOLINT |
---|
| 347 | template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT |
---|
| 348 | |
---|
| 349 | // Invalid<T>() returns an invalid value of type T. This is useful |
---|
| 350 | // when a value of type T is needed for compilation, but the statement |
---|
| 351 | // will not really be executed (or we don't care if the statement |
---|
| 352 | // crashes). |
---|
| 353 | template <typename T> |
---|
| 354 | inline T Invalid() { |
---|
| 355 | return *static_cast<typename remove_reference<T>::type*>(NULL); |
---|
| 356 | } |
---|
| 357 | template <> |
---|
| 358 | inline void Invalid<void>() {} |
---|
| 359 | |
---|
| 360 | // Given a raw type (i.e. having no top-level reference or const |
---|
| 361 | // modifier) RawContainer that's either an STL-style container or a |
---|
| 362 | // native array, class StlContainerView<RawContainer> has the |
---|
| 363 | // following members: |
---|
| 364 | // |
---|
| 365 | // - type is a type that provides an STL-style container view to |
---|
| 366 | // (i.e. implements the STL container concept for) RawContainer; |
---|
| 367 | // - const_reference is a type that provides a reference to a const |
---|
| 368 | // RawContainer; |
---|
| 369 | // - ConstReference(raw_container) returns a const reference to an STL-style |
---|
| 370 | // container view to raw_container, which is a RawContainer. |
---|
| 371 | // - Copy(raw_container) returns an STL-style container view of a |
---|
| 372 | // copy of raw_container, which is a RawContainer. |
---|
| 373 | // |
---|
| 374 | // This generic version is used when RawContainer itself is already an |
---|
| 375 | // STL-style container. |
---|
| 376 | template <class RawContainer> |
---|
| 377 | class StlContainerView { |
---|
| 378 | public: |
---|
| 379 | typedef RawContainer type; |
---|
| 380 | typedef const type& const_reference; |
---|
| 381 | |
---|
| 382 | static const_reference ConstReference(const RawContainer& container) { |
---|
| 383 | // Ensures that RawContainer is not a const type. |
---|
| 384 | testing::StaticAssertTypeEq<RawContainer, |
---|
| 385 | GTEST_REMOVE_CONST_(RawContainer)>(); |
---|
| 386 | return container; |
---|
| 387 | } |
---|
| 388 | static type Copy(const RawContainer& container) { return container; } |
---|
| 389 | }; |
---|
| 390 | |
---|
| 391 | // This specialization is used when RawContainer is a native array type. |
---|
| 392 | template <typename Element, size_t N> |
---|
| 393 | class StlContainerView<Element[N]> { |
---|
| 394 | public: |
---|
| 395 | typedef GTEST_REMOVE_CONST_(Element) RawElement; |
---|
| 396 | typedef internal::NativeArray<RawElement> type; |
---|
| 397 | // NativeArray<T> can represent a native array either by value or by |
---|
| 398 | // reference (selected by a constructor argument), so 'const type' |
---|
| 399 | // can be used to reference a const native array. We cannot |
---|
| 400 | // 'typedef const type& const_reference' here, as that would mean |
---|
| 401 | // ConstReference() has to return a reference to a local variable. |
---|
| 402 | typedef const type const_reference; |
---|
| 403 | |
---|
| 404 | static const_reference ConstReference(const Element (&array)[N]) { |
---|
| 405 | // Ensures that Element is not a const type. |
---|
| 406 | testing::StaticAssertTypeEq<Element, RawElement>(); |
---|
| 407 | #if GTEST_OS_SYMBIAN |
---|
| 408 | // The Nokia Symbian compiler confuses itself in template instantiation |
---|
| 409 | // for this call without the cast to Element*: |
---|
| 410 | // function call '[testing::internal::NativeArray<char *>].NativeArray( |
---|
| 411 | // {lval} const char *[4], long, testing::internal::RelationToSource)' |
---|
| 412 | // does not match |
---|
| 413 | // 'testing::internal::NativeArray<char *>::NativeArray( |
---|
| 414 | // char *const *, unsigned int, testing::internal::RelationToSource)' |
---|
| 415 | // (instantiating: 'testing::internal::ContainsMatcherImpl |
---|
| 416 | // <const char * (&)[4]>::Matches(const char * (&)[4]) const') |
---|
| 417 | // (instantiating: 'testing::internal::StlContainerView<char *[4]>:: |
---|
| 418 | // ConstReference(const char * (&)[4])') |
---|
| 419 | // (and though the N parameter type is mismatched in the above explicit |
---|
| 420 | // conversion of it doesn't help - only the conversion of the array). |
---|
| 421 | return type(const_cast<Element*>(&array[0]), N, kReference); |
---|
| 422 | #else |
---|
| 423 | return type(array, N, kReference); |
---|
| 424 | #endif // GTEST_OS_SYMBIAN |
---|
| 425 | } |
---|
| 426 | static type Copy(const Element (&array)[N]) { |
---|
| 427 | #if GTEST_OS_SYMBIAN |
---|
| 428 | return type(const_cast<Element*>(&array[0]), N, kCopy); |
---|
| 429 | #else |
---|
| 430 | return type(array, N, kCopy); |
---|
| 431 | #endif // GTEST_OS_SYMBIAN |
---|
| 432 | } |
---|
| 433 | }; |
---|
| 434 | |
---|
| 435 | // This specialization is used when RawContainer is a native array |
---|
| 436 | // represented as a (pointer, size) tuple. |
---|
| 437 | template <typename ElementPointer, typename Size> |
---|
| 438 | class StlContainerView< ::std::tr1::tuple<ElementPointer, Size> > { |
---|
| 439 | public: |
---|
| 440 | typedef GTEST_REMOVE_CONST_( |
---|
| 441 | typename internal::PointeeOf<ElementPointer>::type) RawElement; |
---|
| 442 | typedef internal::NativeArray<RawElement> type; |
---|
| 443 | typedef const type const_reference; |
---|
| 444 | |
---|
| 445 | static const_reference ConstReference( |
---|
| 446 | const ::std::tr1::tuple<ElementPointer, Size>& array) { |
---|
| 447 | using ::std::tr1::get; |
---|
| 448 | return type(get<0>(array), get<1>(array), kReference); |
---|
| 449 | } |
---|
| 450 | static type Copy(const ::std::tr1::tuple<ElementPointer, Size>& array) { |
---|
| 451 | using ::std::tr1::get; |
---|
| 452 | return type(get<0>(array), get<1>(array), kCopy); |
---|
| 453 | } |
---|
| 454 | }; |
---|
| 455 | |
---|
| 456 | // The following specialization prevents the user from instantiating |
---|
| 457 | // StlContainer with a reference type. |
---|
| 458 | template <typename T> class StlContainerView<T&>; |
---|
| 459 | |
---|
| 460 | } // namespace internal |
---|
| 461 | } // namespace testing |
---|
| 462 | |
---|
| 463 | #endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ |
---|