src/third_party/protobuf/src/google/protobuf/stubs/type_traits_unittest.cc

   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:
  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:
  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:
  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:
 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:
 164   virtual ~Base() { }
 165 };
 166
 167 class Derived : public Base {
 168 };
 169
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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.
 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
 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
 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
 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
 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
 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
 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