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_ |
---|