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 629
