1 // Copyright (c) 2006, 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 // ----
31 // Author: Matt Austern
32
33 #include <google/protobuf/stubs/type_traits.h>
34
35 #include <stdlib.h> // for exit()
36 #include <stdio.h>
37 #include <string>
38 #include <vector>
39
40 #include <google/protobuf/testing/googletest.h>
41 #include <gtest/gtest.h>
42
43 typedef int int32;
44 typedef long int64;
45
46 using std::string;
47 using std::vector;
48 using std::pair;
49
50
51 // This assertion produces errors like "error: invalid use of
52 // incomplete type 'struct <unnamed>::AssertTypesEq<const int, int>'"
53 // when it fails.
54 template<typename T, typename U> struct AssertTypesEq;
55 template<typename T> struct AssertTypesEq<T, T> {};
56 #define COMPILE_ASSERT_TYPES_EQ(T, U) static_cast<void>(AssertTypesEq<T, U>())
57
58 // A user-defined POD type.
59 struct A {
60 int n_;
61 };
62
63 // A user-defined non-POD type with a trivial copy constructor.
64 class B {
65 public:
B(int n)66 explicit B(int n) : n_(n) { }
67 private:
68 int n_;
69 };
70
71 // Another user-defined non-POD type with a trivial copy constructor.
72 // We will explicitly declare C to have a trivial copy constructor
73 // by specializing has_trivial_copy.
74 class C {
75 public:
C(int n)76 explicit C(int n) : n_(n) { }
77 private:
78 int n_;
79 };
80
81 namespace google {
82 namespace protobuf {
83 namespace internal {
84 template<> struct has_trivial_copy<C> : true_type { };
85 } // namespace internal
86 } // namespace protobuf
87 } // namespace google
88
89 // Another user-defined non-POD type with a trivial assignment operator.
90 // We will explicitly declare C to have a trivial assignment operator
91 // by specializing has_trivial_assign.
92 class D {
93 public:
D(int n)94 explicit D(int n) : n_(n) { }
95 private:
96 int n_;
97 };
98
99 namespace google {
100 namespace protobuf {
101 namespace internal {
102 template<> struct has_trivial_assign<D> : true_type { };
103 } // namespace internal
104 } // namespace protobuf
105 } // namespace google
106
107 // Another user-defined non-POD type with a trivial constructor.
108 // We will explicitly declare E to have a trivial constructor
109 // by specializing has_trivial_constructor.
110 class E {
111 public:
112 int n_;
113 };
114
115 namespace google {
116 namespace protobuf {
117 namespace internal {
118 template<> struct has_trivial_constructor<E> : true_type { };
119 } // namespace internal
120 } // namespace protobuf
121 } // namespace google
122
123 // Another user-defined non-POD type with a trivial destructor.
124 // We will explicitly declare E to have a trivial destructor
125 // by specializing has_trivial_destructor.
126 class F {
127 public:
F(int n)128 explicit F(int n) : n_(n) { }
129 private:
130 int n_;
131 };
132
133 namespace google {
134 namespace protobuf {
135 namespace internal {
136 template<> struct has_trivial_destructor<F> : true_type { };
137 } // namespace internal
138 } // namespace protobuf
139 } // namespace google
140
141 enum G {};
142
143 union H {};
144
145 class I {
146 public:
147 operator int() const;
148 };
149
150 class J {
151 private:
152 operator int() const;
153 };
154
155 namespace google {
156 namespace protobuf {
157 namespace internal {
158 namespace {
159
160 // A base class and a derived class that inherits from it, used for
161 // testing conversion type traits.
162 class Base {
163 public:
~Base()164 virtual ~Base() { }
165 };
166
167 class Derived : public Base {
168 };
169
TEST(TypeTraitsTest,TestIsInteger)170 TEST(TypeTraitsTest, TestIsInteger) {
171 // Verify that is_integral is true for all integer types.
172 EXPECT_TRUE(is_integral<bool>::value);
173 EXPECT_TRUE(is_integral<char>::value);
174 EXPECT_TRUE(is_integral<unsigned char>::value);
175 EXPECT_TRUE(is_integral<signed char>::value);
176 EXPECT_TRUE(is_integral<wchar_t>::value);
177 EXPECT_TRUE(is_integral<int>::value);
178 EXPECT_TRUE(is_integral<unsigned int>::value);
179 EXPECT_TRUE(is_integral<short>::value);
180 EXPECT_TRUE(is_integral<unsigned short>::value);
181 EXPECT_TRUE(is_integral<long>::value);
182 EXPECT_TRUE(is_integral<unsigned long>::value);
183
184 // Verify that is_integral is false for a few non-integer types.
185 EXPECT_FALSE(is_integral<void>::value);
186 EXPECT_FALSE(is_integral<float>::value);
187 EXPECT_FALSE(is_integral<string>::value);
188 EXPECT_FALSE(is_integral<int*>::value);
189 EXPECT_FALSE(is_integral<A>::value);
190 EXPECT_FALSE((is_integral<pair<int, int> >::value));
191
192 // Verify that cv-qualified integral types are still integral, and
193 // cv-qualified non-integral types are still non-integral.
194 EXPECT_TRUE(is_integral<const char>::value);
195 EXPECT_TRUE(is_integral<volatile bool>::value);
196 EXPECT_TRUE(is_integral<const volatile unsigned int>::value);
197 EXPECT_FALSE(is_integral<const float>::value);
198 EXPECT_FALSE(is_integral<int* volatile>::value);
199 EXPECT_FALSE(is_integral<const volatile string>::value);
200 }
201
TEST(TypeTraitsTest,TestIsFloating)202 TEST(TypeTraitsTest, TestIsFloating) {
203 // Verify that is_floating_point is true for all floating-point types.
204 EXPECT_TRUE(is_floating_point<float>::value);
205 EXPECT_TRUE(is_floating_point<double>::value);
206 EXPECT_TRUE(is_floating_point<long double>::value);
207
208 // Verify that is_floating_point is false for a few non-float types.
209 EXPECT_FALSE(is_floating_point<void>::value);
210 EXPECT_FALSE(is_floating_point<long>::value);
211 EXPECT_FALSE(is_floating_point<string>::value);
212 EXPECT_FALSE(is_floating_point<float*>::value);
213 EXPECT_FALSE(is_floating_point<A>::value);
214 EXPECT_FALSE((is_floating_point<pair<int, int> >::value));
215
216 // Verify that cv-qualified floating point types are still floating, and
217 // cv-qualified non-floating types are still non-floating.
218 EXPECT_TRUE(is_floating_point<const float>::value);
219 EXPECT_TRUE(is_floating_point<volatile double>::value);
220 EXPECT_TRUE(is_floating_point<const volatile long double>::value);
221 EXPECT_FALSE(is_floating_point<const int>::value);
222 EXPECT_FALSE(is_floating_point<volatile string>::value);
223 EXPECT_FALSE(is_floating_point<const volatile char>::value);
224 }
225
TEST(TypeTraitsTest,TestIsPointer)226 TEST(TypeTraitsTest, TestIsPointer) {
227 // Verify that is_pointer is true for some pointer types.
228 EXPECT_TRUE(is_pointer<int*>::value);
229 EXPECT_TRUE(is_pointer<void*>::value);
230 EXPECT_TRUE(is_pointer<string*>::value);
231 EXPECT_TRUE(is_pointer<const void*>::value);
232 EXPECT_TRUE(is_pointer<volatile float* const*>::value);
233
234 // Verify that is_pointer is false for some non-pointer types.
235 EXPECT_FALSE(is_pointer<void>::value);
236 EXPECT_FALSE(is_pointer<float&>::value);
237 EXPECT_FALSE(is_pointer<long>::value);
238 EXPECT_FALSE(is_pointer<vector<int*> >::value);
239 EXPECT_FALSE(is_pointer<int[5]>::value);
240
241 // A function pointer is a pointer, but a function type, or a function
242 // reference type, is not.
243 EXPECT_TRUE(is_pointer<int (*)(int x)>::value);
244 EXPECT_FALSE(is_pointer<void(char x)>::value);
245 EXPECT_FALSE(is_pointer<double (&)(string x)>::value);
246
247 // Verify that is_pointer<T> is true for some cv-qualified pointer types,
248 // and false for some cv-qualified non-pointer types.
249 EXPECT_TRUE(is_pointer<int* const>::value);
250 EXPECT_TRUE(is_pointer<const void* volatile>::value);
251 EXPECT_TRUE(is_pointer<char** const volatile>::value);
252 EXPECT_FALSE(is_pointer<const int>::value);
253 EXPECT_FALSE(is_pointer<volatile vector<int*> >::value);
254 EXPECT_FALSE(is_pointer<const volatile double>::value);
255 }
256
TEST(TypeTraitsTest,TestIsEnum)257 TEST(TypeTraitsTest, TestIsEnum) {
258 // is_enum isn't supported on MSVC or gcc 3.x
259 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
260 // Verify that is_enum is true for enum types.
261 EXPECT_TRUE(is_enum<G>::value);
262 EXPECT_TRUE(is_enum<const G>::value);
263 EXPECT_TRUE(is_enum<volatile G>::value);
264 EXPECT_TRUE(is_enum<const volatile G>::value);
265
266 // Verify that is_enum is false for a few non-enum types.
267 EXPECT_FALSE(is_enum<void>::value);
268 EXPECT_FALSE(is_enum<G&>::value);
269 EXPECT_FALSE(is_enum<G[1]>::value);
270 EXPECT_FALSE(is_enum<const G[1]>::value);
271 EXPECT_FALSE(is_enum<G[]>::value);
272 EXPECT_FALSE(is_enum<int>::value);
273 EXPECT_FALSE(is_enum<float>::value);
274 EXPECT_FALSE(is_enum<A>::value);
275 EXPECT_FALSE(is_enum<A*>::value);
276 EXPECT_FALSE(is_enum<const A>::value);
277 EXPECT_FALSE(is_enum<H>::value);
278 EXPECT_FALSE(is_enum<I>::value);
279 EXPECT_FALSE(is_enum<J>::value);
280 EXPECT_FALSE(is_enum<void()>::value);
281 EXPECT_FALSE(is_enum<void(*)()>::value);
282 EXPECT_FALSE(is_enum<int A::*>::value);
283 EXPECT_FALSE(is_enum<void (A::*)()>::value);
284 #endif
285 }
286
TEST(TypeTraitsTest,TestIsReference)287 TEST(TypeTraitsTest, TestIsReference) {
288 // Verifies that is_reference is true for all reference types.
289 typedef float& RefFloat;
290 EXPECT_TRUE(is_reference<float&>::value);
291 EXPECT_TRUE(is_reference<const int&>::value);
292 EXPECT_TRUE(is_reference<const int*&>::value);
293 EXPECT_TRUE(is_reference<int (&)(bool)>::value);
294 EXPECT_TRUE(is_reference<RefFloat>::value);
295 EXPECT_TRUE(is_reference<const RefFloat>::value);
296 EXPECT_TRUE(is_reference<volatile RefFloat>::value);
297 EXPECT_TRUE(is_reference<const volatile RefFloat>::value);
298
299
300 // Verifies that is_reference is false for all non-reference types.
301 EXPECT_FALSE(is_reference<float>::value);
302 EXPECT_FALSE(is_reference<const float>::value);
303 EXPECT_FALSE(is_reference<volatile float>::value);
304 EXPECT_FALSE(is_reference<const volatile float>::value);
305 EXPECT_FALSE(is_reference<const int*>::value);
306 EXPECT_FALSE(is_reference<int()>::value);
307 EXPECT_FALSE(is_reference<void(*)(const char&)>::value);
308 }
309
TEST(TypeTraitsTest,TestAddReference)310 TEST(TypeTraitsTest, TestAddReference) {
311 COMPILE_ASSERT_TYPES_EQ(int&, add_reference<int>::type);
312 COMPILE_ASSERT_TYPES_EQ(const int&, add_reference<const int>::type);
313 COMPILE_ASSERT_TYPES_EQ(volatile int&,
314 add_reference<volatile int>::type);
315 COMPILE_ASSERT_TYPES_EQ(const volatile int&,
316 add_reference<const volatile int>::type);
317 COMPILE_ASSERT_TYPES_EQ(int&, add_reference<int&>::type);
318 COMPILE_ASSERT_TYPES_EQ(const int&, add_reference<const int&>::type);
319 COMPILE_ASSERT_TYPES_EQ(volatile int&,
320 add_reference<volatile int&>::type);
321 COMPILE_ASSERT_TYPES_EQ(const volatile int&,
322 add_reference<const volatile int&>::type);
323 }
324
TEST(TypeTraitsTest,TestIsPod)325 TEST(TypeTraitsTest, TestIsPod) {
326 // Verify that arithmetic types and pointers are marked as PODs.
327 EXPECT_TRUE(is_pod<bool>::value);
328 EXPECT_TRUE(is_pod<char>::value);
329 EXPECT_TRUE(is_pod<unsigned char>::value);
330 EXPECT_TRUE(is_pod<signed char>::value);
331 EXPECT_TRUE(is_pod<wchar_t>::value);
332 EXPECT_TRUE(is_pod<int>::value);
333 EXPECT_TRUE(is_pod<unsigned int>::value);
334 EXPECT_TRUE(is_pod<short>::value);
335 EXPECT_TRUE(is_pod<unsigned short>::value);
336 EXPECT_TRUE(is_pod<long>::value);
337 EXPECT_TRUE(is_pod<unsigned long>::value);
338 EXPECT_TRUE(is_pod<float>::value);
339 EXPECT_TRUE(is_pod<double>::value);
340 EXPECT_TRUE(is_pod<long double>::value);
341 EXPECT_TRUE(is_pod<string*>::value);
342 EXPECT_TRUE(is_pod<A*>::value);
343 EXPECT_TRUE(is_pod<const B*>::value);
344 EXPECT_TRUE(is_pod<C**>::value);
345 EXPECT_TRUE(is_pod<const int>::value);
346 EXPECT_TRUE(is_pod<char* volatile>::value);
347 EXPECT_TRUE(is_pod<const volatile double>::value);
348 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
349 EXPECT_TRUE(is_pod<G>::value);
350 EXPECT_TRUE(is_pod<const G>::value);
351 EXPECT_TRUE(is_pod<volatile G>::value);
352 EXPECT_TRUE(is_pod<const volatile G>::value);
353 #endif
354
355 // Verify that some non-POD types are not marked as PODs.
356 EXPECT_FALSE(is_pod<void>::value);
357 EXPECT_FALSE(is_pod<string>::value);
358 EXPECT_FALSE((is_pod<pair<int, int> >::value));
359 EXPECT_FALSE(is_pod<A>::value);
360 EXPECT_FALSE(is_pod<B>::value);
361 EXPECT_FALSE(is_pod<C>::value);
362 EXPECT_FALSE(is_pod<const string>::value);
363 EXPECT_FALSE(is_pod<volatile A>::value);
364 EXPECT_FALSE(is_pod<const volatile B>::value);
365 }
366
TEST(TypeTraitsTest,TestHasTrivialConstructor)367 TEST(TypeTraitsTest, TestHasTrivialConstructor) {
368 // Verify that arithmetic types and pointers have trivial constructors.
369 EXPECT_TRUE(has_trivial_constructor<bool>::value);
370 EXPECT_TRUE(has_trivial_constructor<char>::value);
371 EXPECT_TRUE(has_trivial_constructor<unsigned char>::value);
372 EXPECT_TRUE(has_trivial_constructor<signed char>::value);
373 EXPECT_TRUE(has_trivial_constructor<wchar_t>::value);
374 EXPECT_TRUE(has_trivial_constructor<int>::value);
375 EXPECT_TRUE(has_trivial_constructor<unsigned int>::value);
376 EXPECT_TRUE(has_trivial_constructor<short>::value);
377 EXPECT_TRUE(has_trivial_constructor<unsigned short>::value);
378 EXPECT_TRUE(has_trivial_constructor<long>::value);
379 EXPECT_TRUE(has_trivial_constructor<unsigned long>::value);
380 EXPECT_TRUE(has_trivial_constructor<float>::value);
381 EXPECT_TRUE(has_trivial_constructor<double>::value);
382 EXPECT_TRUE(has_trivial_constructor<long double>::value);
383 EXPECT_TRUE(has_trivial_constructor<string*>::value);
384 EXPECT_TRUE(has_trivial_constructor<A*>::value);
385 EXPECT_TRUE(has_trivial_constructor<const B*>::value);
386 EXPECT_TRUE(has_trivial_constructor<C**>::value);
387
388 // Verify that pairs and arrays of such types have trivial
389 // constructors.
390 typedef int int10[10];
391 EXPECT_TRUE((has_trivial_constructor<pair<int, char*> >::value));
392 EXPECT_TRUE(has_trivial_constructor<int10>::value);
393
394 // Verify that pairs of types without trivial constructors
395 // are not marked as trivial.
396 EXPECT_FALSE((has_trivial_constructor<pair<int, string> >::value));
397 EXPECT_FALSE((has_trivial_constructor<pair<string, int> >::value));
398
399 // Verify that types without trivial constructors are
400 // correctly marked as such.
401 EXPECT_FALSE(has_trivial_constructor<string>::value);
402 EXPECT_FALSE(has_trivial_constructor<vector<int> >::value);
403
404 // Verify that E, which we have declared to have a trivial
405 // constructor, is correctly marked as such.
406 EXPECT_TRUE(has_trivial_constructor<E>::value);
407 }
408
TEST(TypeTraitsTest,TestHasTrivialCopy)409 TEST(TypeTraitsTest, TestHasTrivialCopy) {
410 // Verify that arithmetic types and pointers have trivial copy
411 // constructors.
412 EXPECT_TRUE(has_trivial_copy<bool>::value);
413 EXPECT_TRUE(has_trivial_copy<char>::value);
414 EXPECT_TRUE(has_trivial_copy<unsigned char>::value);
415 EXPECT_TRUE(has_trivial_copy<signed char>::value);
416 EXPECT_TRUE(has_trivial_copy<wchar_t>::value);
417 EXPECT_TRUE(has_trivial_copy<int>::value);
418 EXPECT_TRUE(has_trivial_copy<unsigned int>::value);
419 EXPECT_TRUE(has_trivial_copy<short>::value);
420 EXPECT_TRUE(has_trivial_copy<unsigned short>::value);
421 EXPECT_TRUE(has_trivial_copy<long>::value);
422 EXPECT_TRUE(has_trivial_copy<unsigned long>::value);
423 EXPECT_TRUE(has_trivial_copy<float>::value);
424 EXPECT_TRUE(has_trivial_copy<double>::value);
425 EXPECT_TRUE(has_trivial_copy<long double>::value);
426 EXPECT_TRUE(has_trivial_copy<string*>::value);
427 EXPECT_TRUE(has_trivial_copy<A*>::value);
428 EXPECT_TRUE(has_trivial_copy<const B*>::value);
429 EXPECT_TRUE(has_trivial_copy<C**>::value);
430
431 // Verify that pairs and arrays of such types have trivial
432 // copy constructors.
433 typedef int int10[10];
434 EXPECT_TRUE((has_trivial_copy<pair<int, char*> >::value));
435 EXPECT_TRUE(has_trivial_copy<int10>::value);
436
437 // Verify that pairs of types without trivial copy constructors
438 // are not marked as trivial.
439 EXPECT_FALSE((has_trivial_copy<pair<int, string> >::value));
440 EXPECT_FALSE((has_trivial_copy<pair<string, int> >::value));
441
442 // Verify that types without trivial copy constructors are
443 // correctly marked as such.
444 EXPECT_FALSE(has_trivial_copy<string>::value);
445 EXPECT_FALSE(has_trivial_copy<vector<int> >::value);
446
447 // Verify that C, which we have declared to have a trivial
448 // copy constructor, is correctly marked as such.
449 EXPECT_TRUE(has_trivial_copy<C>::value);
450 }
451
TEST(TypeTraitsTest,TestHasTrivialAssign)452 TEST(TypeTraitsTest, TestHasTrivialAssign) {
453 // Verify that arithmetic types and pointers have trivial assignment
454 // operators.
455 EXPECT_TRUE(has_trivial_assign<bool>::value);
456 EXPECT_TRUE(has_trivial_assign<char>::value);
457 EXPECT_TRUE(has_trivial_assign<unsigned char>::value);
458 EXPECT_TRUE(has_trivial_assign<signed char>::value);
459 EXPECT_TRUE(has_trivial_assign<wchar_t>::value);
460 EXPECT_TRUE(has_trivial_assign<int>::value);
461 EXPECT_TRUE(has_trivial_assign<unsigned int>::value);
462 EXPECT_TRUE(has_trivial_assign<short>::value);
463 EXPECT_TRUE(has_trivial_assign<unsigned short>::value);
464 EXPECT_TRUE(has_trivial_assign<long>::value);
465 EXPECT_TRUE(has_trivial_assign<unsigned long>::value);
466 EXPECT_TRUE(has_trivial_assign<float>::value);
467 EXPECT_TRUE(has_trivial_assign<double>::value);
468 EXPECT_TRUE(has_trivial_assign<long double>::value);
469 EXPECT_TRUE(has_trivial_assign<string*>::value);
470 EXPECT_TRUE(has_trivial_assign<A*>::value);
471 EXPECT_TRUE(has_trivial_assign<const B*>::value);
472 EXPECT_TRUE(has_trivial_assign<C**>::value);
473
474 // Verify that pairs and arrays of such types have trivial
475 // assignment operators.
476 typedef int int10[10];
477 EXPECT_TRUE((has_trivial_assign<pair<int, char*> >::value));
478 EXPECT_TRUE(has_trivial_assign<int10>::value);
479
480 // Verify that pairs of types without trivial assignment operators
481 // are not marked as trivial.
482 EXPECT_FALSE((has_trivial_assign<pair<int, string> >::value));
483 EXPECT_FALSE((has_trivial_assign<pair<string, int> >::value));
484
485 // Verify that types without trivial assignment operators are
486 // correctly marked as such.
487 EXPECT_FALSE(has_trivial_assign<string>::value);
488 EXPECT_FALSE(has_trivial_assign<vector<int> >::value);
489
490 // Verify that D, which we have declared to have a trivial
491 // assignment operator, is correctly marked as such.
492 EXPECT_TRUE(has_trivial_assign<D>::value);
493 }
494
TEST(TypeTraitsTest,TestHasTrivialDestructor)495 TEST(TypeTraitsTest, TestHasTrivialDestructor) {
496 // Verify that arithmetic types and pointers have trivial destructors.
497 EXPECT_TRUE(has_trivial_destructor<bool>::value);
498 EXPECT_TRUE(has_trivial_destructor<char>::value);
499 EXPECT_TRUE(has_trivial_destructor<unsigned char>::value);
500 EXPECT_TRUE(has_trivial_destructor<signed char>::value);
501 EXPECT_TRUE(has_trivial_destructor<wchar_t>::value);
502 EXPECT_TRUE(has_trivial_destructor<int>::value);
503 EXPECT_TRUE(has_trivial_destructor<unsigned int>::value);
504 EXPECT_TRUE(has_trivial_destructor<short>::value);
505 EXPECT_TRUE(has_trivial_destructor<unsigned short>::value);
506 EXPECT_TRUE(has_trivial_destructor<long>::value);
507 EXPECT_TRUE(has_trivial_destructor<unsigned long>::value);
508 EXPECT_TRUE(has_trivial_destructor<float>::value);
509 EXPECT_TRUE(has_trivial_destructor<double>::value);
510 EXPECT_TRUE(has_trivial_destructor<long double>::value);
511 EXPECT_TRUE(has_trivial_destructor<string*>::value);
512 EXPECT_TRUE(has_trivial_destructor<A*>::value);
513 EXPECT_TRUE(has_trivial_destructor<const B*>::value);
514 EXPECT_TRUE(has_trivial_destructor<C**>::value);
515
516 // Verify that pairs and arrays of such types have trivial
517 // destructors.
518 typedef int int10[10];
519 EXPECT_TRUE((has_trivial_destructor<pair<int, char*> >::value));
520 EXPECT_TRUE(has_trivial_destructor<int10>::value);
521
522 // Verify that pairs of types without trivial destructors
523 // are not marked as trivial.
524 EXPECT_FALSE((has_trivial_destructor<pair<int, string> >::value));
525 EXPECT_FALSE((has_trivial_destructor<pair<string, int> >::value));
526
527 // Verify that types without trivial destructors are
528 // correctly marked as such.
529 EXPECT_FALSE(has_trivial_destructor<string>::value);
530 EXPECT_FALSE(has_trivial_destructor<vector<int> >::value);
531
532 // Verify that F, which we have declared to have a trivial
533 // destructor, is correctly marked as such.
534 EXPECT_TRUE(has_trivial_destructor<F>::value);
535 }
536
537 // Tests remove_pointer.
TEST(TypeTraitsTest,TestRemovePointer)538 TEST(TypeTraitsTest, TestRemovePointer) {
539 COMPILE_ASSERT_TYPES_EQ(int, remove_pointer<int>::type);
540 COMPILE_ASSERT_TYPES_EQ(int, remove_pointer<int*>::type);
541 COMPILE_ASSERT_TYPES_EQ(const int, remove_pointer<const int*>::type);
542 COMPILE_ASSERT_TYPES_EQ(int, remove_pointer<int* const>::type);
543 COMPILE_ASSERT_TYPES_EQ(int, remove_pointer<int* volatile>::type);
544 }
545
TEST(TypeTraitsTest,TestRemoveConst)546 TEST(TypeTraitsTest, TestRemoveConst) {
547 COMPILE_ASSERT_TYPES_EQ(int, remove_const<int>::type);
548 COMPILE_ASSERT_TYPES_EQ(int, remove_const<const int>::type);
549 COMPILE_ASSERT_TYPES_EQ(int *, remove_const<int * const>::type);
550 // TR1 examples.
551 COMPILE_ASSERT_TYPES_EQ(const int *, remove_const<const int *>::type);
552 COMPILE_ASSERT_TYPES_EQ(volatile int,
553 remove_const<const volatile int>::type);
554 }
555
TEST(TypeTraitsTest,TestRemoveVolatile)556 TEST(TypeTraitsTest, TestRemoveVolatile) {
557 COMPILE_ASSERT_TYPES_EQ(int, remove_volatile<int>::type);
558 COMPILE_ASSERT_TYPES_EQ(int, remove_volatile<volatile int>::type);
559 COMPILE_ASSERT_TYPES_EQ(int *, remove_volatile<int * volatile>::type);
560 // TR1 examples.
561 COMPILE_ASSERT_TYPES_EQ(volatile int *,
562 remove_volatile<volatile int *>::type);
563 COMPILE_ASSERT_TYPES_EQ(const int,
564 remove_volatile<const volatile int>::type);
565 }
566
TEST(TypeTraitsTest,TestRemoveCV)567 TEST(TypeTraitsTest, TestRemoveCV) {
568 COMPILE_ASSERT_TYPES_EQ(int, remove_cv<int>::type);
569 COMPILE_ASSERT_TYPES_EQ(int, remove_cv<volatile int>::type);
570 COMPILE_ASSERT_TYPES_EQ(int, remove_cv<const int>::type);
571 COMPILE_ASSERT_TYPES_EQ(int *, remove_cv<int * const volatile>::type);
572 // TR1 examples.
573 COMPILE_ASSERT_TYPES_EQ(const volatile int *,
574 remove_cv<const volatile int *>::type);
575 COMPILE_ASSERT_TYPES_EQ(int,
576 remove_cv<const volatile int>::type);
577 }
578
TEST(TypeTraitsTest,TestRemoveReference)579 TEST(TypeTraitsTest, TestRemoveReference) {
580 COMPILE_ASSERT_TYPES_EQ(int, remove_reference<int>::type);
581 COMPILE_ASSERT_TYPES_EQ(int, remove_reference<int&>::type);
582 COMPILE_ASSERT_TYPES_EQ(const int, remove_reference<const int&>::type);
583 COMPILE_ASSERT_TYPES_EQ(int*, remove_reference<int * &>::type);
584 }
585
TEST(TypeTraitsTest,TestIsSame)586 TEST(TypeTraitsTest, TestIsSame) {
587 EXPECT_TRUE((is_same<int32, int32>::value));
588 EXPECT_FALSE((is_same<int32, int64>::value));
589 EXPECT_FALSE((is_same<int64, int32>::value));
590 EXPECT_FALSE((is_same<int, const int>::value));
591
592 EXPECT_TRUE((is_same<void, void>::value));
593 EXPECT_FALSE((is_same<void, int>::value));
594 EXPECT_FALSE((is_same<int, void>::value));
595
596 EXPECT_TRUE((is_same<int*, int*>::value));
597 EXPECT_TRUE((is_same<void*, void*>::value));
598 EXPECT_FALSE((is_same<int*, void*>::value));
599 EXPECT_FALSE((is_same<void*, int*>::value));
600 EXPECT_FALSE((is_same<void*, const void*>::value));
601 EXPECT_FALSE((is_same<void*, void* const>::value));
602
603 EXPECT_TRUE((is_same<Base*, Base*>::value));
604 EXPECT_TRUE((is_same<Derived*, Derived*>::value));
605 EXPECT_FALSE((is_same<Base*, Derived*>::value));
606 EXPECT_FALSE((is_same<Derived*, Base*>::value));
607 }
608
TEST(TypeTraitsTest,TestConvertible)609 TEST(TypeTraitsTest, TestConvertible) {
610 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
611 EXPECT_TRUE((is_convertible<int, int>::value));
612 EXPECT_TRUE((is_convertible<int, long>::value));
613 EXPECT_TRUE((is_convertible<long, int>::value));
614
615 EXPECT_TRUE((is_convertible<int*, void*>::value));
616 EXPECT_FALSE((is_convertible<void*, int*>::value));
617
618 EXPECT_TRUE((is_convertible<Derived*, Base*>::value));
619 EXPECT_FALSE((is_convertible<Base*, Derived*>::value));
620 EXPECT_TRUE((is_convertible<Derived*, const Base*>::value));
621 EXPECT_FALSE((is_convertible<const Derived*, Base*>::value));
622 #endif
623 }
624
625 } // anonymous namespace
626 } // namespace internal
627 } // namespace protobuf
628 } // namespace google
629