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