boost/utility
2
0
Fork 0
mirror of https://github.com/boostorg/utility.git synced 2026-01-28 07:42:15 +00:00
Code Issues Projects Releases Wiki Activity
Files
2e0ee55b5e5c04787adfbb91c4d88112caee8ca7
utility/type_traits_test.cpp
Jeremy Siek a9951376f4 removed UDT -> int is_convertible test because the noncopyable -> int 
test already brings out the g++ warning


[SVN r8834]
2001-01-31 19:08:27 +00:00

673 lines
28 KiB
C++
Raw Blame History

// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// standalone test program for <boost/type_traits.hpp>
/* Release notes:
31 Jan 2001:
Added a test for is_array using a const array and a test for
is_convertible with a user-defined implicit conversion. Changed
signature of main() so that this program will link under
MSVC. (Jeremy Siek)
20 Jan 2001:
Suppress an expected warning for MSVC
Added a test to prove that we can use void with is_same<>
Removed "press any key to exit" as it interferes with testing in large
batches.
(David Abahams)
31st July 2000:
Added extra tests for is_empty, is_convertible, alignment_of.
23rd July 2000:
Removed all call_traits tests to call_traits_test.cpp
Removed all compressed_pair tests to compressed_pair_tests.cpp
Improved tests macros
Tidied up specialistions of type_types classes for test cases. */
#include <iostream>
#include <typeinfo>
#include <boost/type_traits.hpp>
#include <boost/utility.hpp>
#include "type_traits_test.hpp"
using namespace boost;
// Since there is no compiler support, we should specialize:
// is_enum for all enumerations (is_enum implies is_POD)
// is_union for all unions
// is_empty for all empty composites
// is_POD for all PODs (except enums) (is_POD implies has_*)
// has_* for any UDT that has that trait and is not POD
enum enum_UDT{ one, two, three };
struct UDT
{
UDT();
~UDT();
UDT(const UDT&);
UDT& operator=(const UDT&);
int i;
void f1();
int f2();
int f3(int);
int f4(int, float);
};
struct POD_UDT { int x; };
struct empty_UDT{ ~empty_UDT(){}; };
struct empty_POD_UDT{};
union union_UDT
{
int x;
double y;
~union_UDT();
};
union POD_union_UDT
{
int x;
double y;
};
union empty_union_UDT
{
~empty_union_UDT();
};
union empty_POD_union_UDT{};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
namespace boost {
template <> struct is_enum<enum_UDT>
{ static const bool value = true; };
template <> struct is_POD<POD_UDT>
{ static const bool value = true; };
// this type is not POD, so we have to specialize the has_* individually
template <> struct has_trivial_constructor<empty_UDT>
{ static const bool value = true; };
template <> struct has_trivial_copy<empty_UDT>
{ static const bool value = true; };
template <> struct has_trivial_assign<empty_UDT>
{ static const bool value = true; };
template <> struct is_POD<empty_POD_UDT>
{ static const bool value = true; };
template <> struct is_union<union_UDT>
{ static const bool value = true; };
template <> struct is_union<POD_union_UDT>
{ static const bool value = true; };
template <> struct is_POD<POD_union_UDT>
{ static const bool value = true; };
template <> struct is_union<empty_union_UDT>
{ static const bool value = true; };
// this type is not POD, so we have to specialize the has_* individually
template <> struct has_trivial_constructor<empty_union_UDT>
{ static const bool value = true; };
template <> struct has_trivial_copy<empty_union_UDT>
{ static const bool value = true; };
template <> struct has_trivial_assign<empty_union_UDT>
{ static const bool value = true; };
template <> struct is_union<empty_POD_union_UDT>
{ static const bool value = true; };
template <> struct is_POD<empty_POD_union_UDT>
{ static const bool value = true; };
}
#else
namespace boost {
template <> struct is_enum<enum_UDT>
{ enum{ value = true }; };
template <> struct is_POD<POD_UDT>
{ enum{ value = true }; };
// this type is not POD, so we have to specialize the has_* individually
template <> struct has_trivial_constructor<empty_UDT>
{ enum{ value = true }; };
template <> struct has_trivial_copy<empty_UDT>
{ enum{ value = true }; };
template <> struct has_trivial_assign<empty_UDT>
{ enum{ value = true }; };
template <> struct is_POD<empty_POD_UDT>
{ enum{ value = true }; };
template <> struct is_union<union_UDT>
{ enum{ value = true }; };
template <> struct is_union<POD_union_UDT>
{ enum{ value = true }; };
template <> struct is_POD<POD_union_UDT>
{ enum{ value = true }; };
template <> struct is_union<empty_union_UDT>
{ enum{ value = true }; };
// this type is not POD, so we have to specialize the has_* individually
template <> struct has_trivial_constructor<empty_union_UDT>
{ enum{ value = true }; };
template <> struct has_trivial_copy<empty_union_UDT>
{ enum{ value = true }; };
template <> struct has_trivial_assign<empty_union_UDT>
{ enum{ value = true }; };
template <> struct is_union<empty_POD_union_UDT>
{ enum{ value = true }; };
template <> struct is_POD<empty_POD_union_UDT>
{ enum{ value = true }; };
}
#endif
class Base { };
class Derived : public Base { };
class NonDerived { };
enum enum1
{
one_,two_
};
enum enum2
{
three_,four_
};
struct VB
{
virtual ~VB(){};
};
struct VD : VB
{
~VD(){};
};
//
// struct non_pointer:
// used to verify that is_pointer does not return
// true for class types that implement operator void*()
//
struct non_pointer
{
operator void*(){return this;}
};
//
// struct non_empty:
// used to verify that is_empty does not emit
// spurious warnings or errors.
//
struct non_empty : boost::noncopyable
{
int i;
};
struct implicitly_convertible_to_int {
operator int() { return 0; }
};
// Steve: All comments that I (Steve Cleary) have added below are prefixed with
// "Steve:" The failures that BCB4 has on the tests are due to Borland's
// not considering cv-qual's as a part of the type -- they are considered
// compiler hints only. These failures should be fixed before long.
int main(int, char*[])
{
std::cout << "Checking type operations..." << std::endl << std::endl;
// cv-qualifiers applied to reference types should have no effect
// declare these here for later use with is_reference and remove_reference:
typedef int& r_type;
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable:4181) // qualifier applied to reference type ignored
#endif
typedef const r_type cr_type;
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
type_test(int, remove_reference<int>::type)
type_test(const int, remove_reference<const int>::type)
type_test(int, remove_reference<int&>::type)
type_test(const int, remove_reference<const int&>::type)
type_test(volatile int, remove_reference<volatile int&>::type)
type_test(int, remove_reference<cr_type>::type)
type_test(int, remove_const<const int>::type)
// Steve: fails on BCB4
type_test(volatile int, remove_const<volatile int>::type)
// Steve: fails on BCB4
type_test(volatile int, remove_const<const volatile int>::type)
type_test(int, remove_const<int>::type)
type_test(int*, remove_const<int* const>::type)
type_test(int, remove_volatile<volatile int>::type)
// Steve: fails on BCB4
type_test(const int, remove_volatile<const int>::type)
// Steve: fails on BCB4
type_test(const int, remove_volatile<const volatile int>::type)
type_test(int, remove_volatile<int>::type)
type_test(int*, remove_volatile<int* volatile>::type)
type_test(int, remove_cv<volatile int>::type)
type_test(int, remove_cv<const int>::type)
type_test(int, remove_cv<const volatile int>::type)
type_test(int, remove_cv<int>::type)
type_test(int*, remove_cv<int* volatile>::type)
type_test(int*, remove_cv<int* const>::type)
type_test(int*, remove_cv<int* const volatile>::type)
type_test(const int *, remove_cv<const int * const>::type)
type_test(int, remove_bounds<int>::type)
type_test(int*, remove_bounds<int*>::type)
type_test(int, remove_bounds<int[3]>::type)
type_test(int[3], remove_bounds<int[2][3]>::type)
std::cout << std::endl << "Checking type properties..." << std::endl << std::endl;
value_test(true, (is_same<void, void>::value))
value_test(false, (is_same<int, void>::value))
value_test(false, (is_same<void, int>::value))
value_test(true, (is_same<int, int>::value))
value_test(false, (is_same<int, const int>::value))
value_test(false, (is_same<int, int&>::value))
value_test(false, (is_same<int*, const int*>::value))
value_test(false, (is_same<int*, int*const>::value))
value_test(false, (is_same<int, int[2]>::value))
value_test(false, (is_same<int*, int[2]>::value))
value_test(false, (is_same<int[4], int[2]>::value))
value_test(false, is_const<int>::value)
value_test(true, is_const<const int>::value)
value_test(false, is_const<volatile int>::value)
value_test(true, is_const<const volatile int>::value)
value_test(false, is_volatile<int>::value)
value_test(false, is_volatile<const int>::value)
value_test(true, is_volatile<volatile int>::value)
value_test(true, is_volatile<const volatile int>::value)
value_test(true, is_void<void>::value)
// Steve: fails on BCB4
// JM: but looks as though it should according to [3.9.3p1]?
//value_test(false, is_void<const void>::value)
value_test(false, is_void<int>::value)
value_test(false, is_standard_unsigned_integral<UDT>::value)
value_test(false, is_standard_unsigned_integral<void>::value)
value_test(false, is_standard_unsigned_integral<bool>::value)
value_test(false, is_standard_unsigned_integral<char>::value)
value_test(false, is_standard_unsigned_integral<signed char>::value)
value_test(true, is_standard_unsigned_integral<unsigned char>::value)
value_test(false, is_standard_unsigned_integral<wchar_t>::value)
value_test(false, is_standard_unsigned_integral<short>::value)
value_test(true, is_standard_unsigned_integral<unsigned short>::value)
value_test(false, is_standard_unsigned_integral<int>::value)
value_test(true, is_standard_unsigned_integral<unsigned int>::value)
value_test(false, is_standard_unsigned_integral<long>::value)
value_test(true, is_standard_unsigned_integral<unsigned long>::value)
value_test(false, is_standard_unsigned_integral<float>::value)
value_test(false, is_standard_unsigned_integral<double>::value)
value_test(false, is_standard_unsigned_integral<long double>::value)
#ifdef ULLONG_MAX
value_test(false, is_standard_unsigned_integral<long long>::value)
value_test(false, is_standard_unsigned_integral<unsigned long long>::value)
#endif
#if defined(__BORLANDC__) || defined(_MSC_VER)
value_test(false, is_standard_unsigned_integral<__int64>::value)
value_test(false, is_standard_unsigned_integral<unsigned __int64>::value)
#endif
value_test(false, is_standard_signed_integral<UDT>::value)
value_test(false, is_standard_signed_integral<void>::value)
value_test(false, is_standard_signed_integral<bool>::value)
value_test(false, is_standard_signed_integral<char>::value)
value_test(true, is_standard_signed_integral<signed char>::value)
value_test(false, is_standard_signed_integral<unsigned char>::value)
value_test(false, is_standard_signed_integral<wchar_t>::value)
value_test(true, is_standard_signed_integral<short>::value)
value_test(false, is_standard_signed_integral<unsigned short>::value)
value_test(true, is_standard_signed_integral<int>::value)
value_test(false, is_standard_signed_integral<unsigned int>::value)
value_test(true, is_standard_signed_integral<long>::value)
value_test(false, is_standard_signed_integral<unsigned long>::value)
value_test(false, is_standard_signed_integral<float>::value)
value_test(false, is_standard_signed_integral<double>::value)
value_test(false, is_standard_signed_integral<long double>::value)
#ifdef ULLONG_MAX
value_test(false, is_standard_signed_integral<long long>::value)
value_test(false, is_standard_signed_integral<unsigned long long>::value)
#endif
#if defined(__BORLANDC__) || defined(_MSC_VER)
value_test(false, is_standard_signed_integral<__int64>::value)
value_test(false, is_standard_signed_integral<unsigned __int64>::value)
#endif
value_test(false, is_standard_arithmetic<UDT>::value)
value_test(false, is_standard_arithmetic<void>::value)
value_test(true, is_standard_arithmetic<bool>::value)
value_test(true, is_standard_arithmetic<char>::value)
value_test(true, is_standard_arithmetic<signed char>::value)
value_test(true, is_standard_arithmetic<unsigned char>::value)
value_test(true, is_standard_arithmetic<wchar_t>::value)
value_test(true, is_standard_arithmetic<short>::value)
value_test(true, is_standard_arithmetic<unsigned short>::value)
value_test(true, is_standard_arithmetic<int>::value)
value_test(true, is_standard_arithmetic<unsigned int>::value)
value_test(true, is_standard_arithmetic<long>::value)
value_test(true, is_standard_arithmetic<unsigned long>::value)
value_test(true, is_standard_arithmetic<float>::value)
value_test(true, is_standard_arithmetic<double>::value)
value_test(true, is_standard_arithmetic<long double>::value)
#ifdef ULLONG_MAX
value_test(false, is_standard_arithmetic<long long>::value)
value_test(false, is_standard_arithmetic<unsigned long long>::value)
#endif
#if defined(__BORLANDC__) || defined(_MSC_VER)
value_test(false, is_standard_arithmetic<__int64>::value)
value_test(false, is_standard_arithmetic<unsigned __int64>::value)
#endif
value_test(false, is_standard_fundamental<UDT>::value)
value_test(true, is_standard_fundamental<void>::value)
value_test(true, is_standard_fundamental<bool>::value)
value_test(true, is_standard_fundamental<char>::value)
value_test(true, is_standard_fundamental<signed char>::value)
value_test(true, is_standard_fundamental<unsigned char>::value)
value_test(true, is_standard_fundamental<wchar_t>::value)
value_test(true, is_standard_fundamental<short>::value)
value_test(true, is_standard_fundamental<unsigned short>::value)
value_test(true, is_standard_fundamental<int>::value)
value_test(true, is_standard_fundamental<unsigned int>::value)
value_test(true, is_standard_fundamental<long>::value)
value_test(true, is_standard_fundamental<unsigned long>::value)
value_test(true, is_standard_fundamental<float>::value)
value_test(true, is_standard_fundamental<double>::value)
value_test(true, is_standard_fundamental<long double>::value)
#ifdef ULLONG_MAX
value_test(false, is_standard_fundamental<long long>::value)
value_test(false, is_standard_fundamental<unsigned long long>::value)
#endif
#if defined(__BORLANDC__) || defined(_MSC_VER)
value_test(false, is_standard_fundamental<__int64>::value)
value_test(false, is_standard_fundamental<unsigned __int64>::value)
#endif
value_test(false, is_arithmetic<UDT>::value)
value_test(true, is_arithmetic<char>::value)
value_test(true, is_arithmetic<signed char>::value)
value_test(true, is_arithmetic<unsigned char>::value)
value_test(true, is_arithmetic<wchar_t>::value)
value_test(true, is_arithmetic<short>::value)
value_test(true, is_arithmetic<unsigned short>::value)
value_test(true, is_arithmetic<int>::value)
value_test(true, is_arithmetic<unsigned int>::value)
value_test(true, is_arithmetic<long>::value)
value_test(true, is_arithmetic<unsigned long>::value)
value_test(true, is_arithmetic<float>::value)
value_test(true, is_arithmetic<double>::value)
value_test(true, is_arithmetic<long double>::value)
value_test(true, is_arithmetic<bool>::value)
#ifdef ULLONG_MAX
value_test(true, is_arithmetic<long long>::value)
value_test(true, is_arithmetic<unsigned long long>::value)
#endif
#if defined(__BORLANDC__) || defined(_MSC_VER)
value_test(true, is_arithmetic<__int64>::value)
value_test(true, is_arithmetic<unsigned __int64>::value)
#endif
value_test(false, is_array<int>::value)
value_test(false, is_array<int*>::value)
value_test(false, is_array<const int*>::value)
value_test(false, is_array<const volatile int*>::value)
value_test(true, is_array<int[2]>::value)
value_test(true, is_array<const int[2]>::value)
value_test(true, is_array<const volatile int[2]>::value)
value_test(true, is_array<int[2][3]>::value)
value_test(true, is_array<UDT[2]>::value)
value_test(false, is_array<int(&)[2]>::value)
value_test(true, is_array<const int[2]>::value)
typedef void(*f1)();
typedef int(*f2)(int);
typedef int(*f3)(int, bool);
typedef void (UDT::*mf1)();
typedef int (UDT::*mf2)();
typedef int (UDT::*mf3)(int);
typedef int (UDT::*mf4)(int, float);
value_test(false, is_const<f1>::value)
value_test(false, is_reference<f1>::value)
value_test(false, is_array<f1>::value)
value_test(false, is_pointer<int>::value)
value_test(false, is_pointer<int&>::value)
value_test(true, is_pointer<int*>::value)
value_test(true, is_pointer<const int*>::value)
value_test(true, is_pointer<volatile int*>::value)
value_test(true, is_pointer<non_pointer*>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
value_test(false, is_pointer<int*const>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
value_test(false, is_pointer<int*volatile>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
value_test(false, is_pointer<int*const volatile>::value)
// JM 02 Oct 2000:
value_test(false, is_pointer<non_pointer>::value)
value_test(false, is_pointer<int*&>::value)
value_test(false, is_pointer<int(&)[2]>::value)
value_test(false, is_pointer<int[2]>::value)
value_test(false, is_pointer<char[sizeof(void*)]>::value)
value_test(true, is_pointer<f1>::value)
value_test(true, is_pointer<f2>::value)
value_test(true, is_pointer<f3>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3
value_test(false, is_pointer<mf1>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3
value_test(false, is_pointer<mf2>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3
value_test(false, is_pointer<mf3>::value)
// Steve: was 'true', should be 'false', via 3.9.2p3
value_test(false, is_pointer<mf4>::value)
value_test(false, is_reference<bool>::value)
value_test(true, is_reference<int&>::value)
value_test(true, is_reference<const int&>::value)
value_test(true, is_reference<volatile int &>::value)
value_test(true, is_reference<r_type>::value)
value_test(true, is_reference<cr_type>::value)
value_test(true, is_reference<const UDT&>::value)
value_test(false, is_class<int>::value)
value_test(false, is_class<const int>::value)
value_test(false, is_class<volatile int>::value)
value_test(false, is_class<int*>::value)
value_test(false, is_class<int* const>::value)
value_test(false, is_class<int[2]>::value)
value_test(false, is_class<int&>::value)
value_test(false, is_class<mf4>::value)
value_test(false, is_class<f1>::value)
value_test(false, is_class<enum_UDT>::value)
value_test(true, is_class<UDT>::value)
value_test(true, is_class<UDT const>::value)
value_test(true, is_class<UDT volatile>::value)
value_test(true, is_class<empty_UDT>::value)
value_test(true, is_class<std::iostream>::value)
value_test(false, is_class<UDT*>::value)
value_test(false, is_class<UDT[2]>::value)
value_test(false, is_class<UDT&>::value)
value_test(true, is_object<int>::value)
value_test(true, is_object<UDT>::value)
value_test(false, is_object<int&>::value)
value_test(false, is_object<void>::value)
value_test(true, is_standard_scalar<int>::value)
value_test(true, is_extension_scalar<void*>::value)
value_test(false, is_enum<int>::value)
value_test(true, is_enum<enum_UDT>::value)
value_test(false, is_member_pointer<f1>::value)
value_test(false, is_member_pointer<f2>::value)
value_test(false, is_member_pointer<f3>::value)
value_test(true, is_member_pointer<mf1>::value)
value_test(true, is_member_pointer<mf2>::value)
value_test(true, is_member_pointer<mf3>::value)
value_test(true, is_member_pointer<mf4>::value)
value_test(false, is_empty<int>::value)
value_test(false, is_empty<int*>::value)
value_test(false, is_empty<int&>::value)
#if defined(__MWERKS__) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
// apparent compiler bug causes this to fail to compile:
value_fail(false, is_empty<int[2]>::value)
#else
value_test(false, is_empty<int[2]>::value)
#endif
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
value_fail(false, is_empty<f1>::value)
#else
value_test(false, is_empty<f1>::value)
#endif
value_test(false, is_empty<mf1>::value)
value_test(false, is_empty<UDT>::value)
value_test(true, is_empty<empty_UDT>::value)
value_test(true, is_empty<empty_POD_UDT>::value)
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
value_fail(true, is_empty<empty_union_UDT>::value)
#else
value_test(true, is_empty<empty_union_UDT>::value)
#endif
value_test(false, is_empty<enum_UDT>::value)
value_test(true, is_empty<boost::noncopyable>::value)
value_test(false, is_empty<non_empty>::value)
value_test(true, has_trivial_constructor<int>::value)
value_test(true, has_trivial_constructor<int*>::value)
value_test(true, has_trivial_constructor<int*const>::value)
value_test(true, has_trivial_constructor<const int>::value)
value_test(true, has_trivial_constructor<volatile int>::value)
value_test(true, has_trivial_constructor<int[2]>::value)
value_test(true, has_trivial_constructor<int[3][2]>::value)
value_test(true, has_trivial_constructor<int[2][4][5][6][3]>::value)
value_test(true, has_trivial_constructor<f1>::value)
value_test(true, has_trivial_constructor<mf2>::value)
value_test(false, has_trivial_constructor<UDT>::value)
value_test(true, has_trivial_constructor<empty_UDT>::value)
value_test(true, has_trivial_constructor<enum_UDT>::value)
value_test(true, has_trivial_copy<int>::value)
value_test(true, has_trivial_copy<int*>::value)
value_test(true, has_trivial_copy<int*const>::value)
value_test(true, has_trivial_copy<const int>::value)
// Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
value_test(true, has_trivial_copy<volatile int>::value)
value_test(true, has_trivial_copy<int[2]>::value)
value_test(true, has_trivial_copy<int[3][2]>::value)
value_test(true, has_trivial_copy<int[2][4][5][6][3]>::value)
value_test(true, has_trivial_copy<f1>::value)
value_test(true, has_trivial_copy<mf2>::value)
value_test(false, has_trivial_copy<UDT>::value)
value_test(true, has_trivial_copy<empty_UDT>::value)
value_test(true, has_trivial_copy<enum_UDT>::value)
value_test(true, has_trivial_assign<int>::value)
value_test(true, has_trivial_assign<int*>::value)
value_test(true, has_trivial_assign<int*const>::value)
value_test(true, has_trivial_assign<const int>::value)
// Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
value_test(true, has_trivial_assign<volatile int>::value)
value_test(true, has_trivial_assign<int[2]>::value)
value_test(true, has_trivial_assign<int[3][2]>::value)
value_test(true, has_trivial_assign<int[2][4][5][6][3]>::value)
value_test(true, has_trivial_assign<f1>::value)
value_test(true, has_trivial_assign<mf2>::value)
value_test(false, has_trivial_assign<UDT>::value)
value_test(true, has_trivial_assign<empty_UDT>::value)
value_test(true, has_trivial_assign<enum_UDT>::value)
value_test(true, has_trivial_destructor<int>::value)
value_test(true, has_trivial_destructor<int*>::value)
value_test(true, has_trivial_destructor<int*const>::value)
value_test(true, has_trivial_destructor<const int>::value)
value_test(true, has_trivial_destructor<volatile int>::value)
value_test(true, has_trivial_destructor<int[2]>::value)
value_test(true, has_trivial_destructor<int[3][2]>::value)
value_test(true, has_trivial_destructor<int[2][4][5][6][3]>::value)
value_test(true, has_trivial_destructor<f1>::value)
value_test(true, has_trivial_destructor<mf2>::value)
value_test(false, has_trivial_destructor<UDT>::value)
value_test(false, has_trivial_destructor<empty_UDT>::value)
value_test(true, has_trivial_destructor<enum_UDT>::value)
value_test(true, is_POD<int>::value)
value_test(true, is_POD<int*>::value)
// Steve: was 'true', should be 'false', via 3.9p10
value_test(false, is_POD<int&>::value)
value_test(true, is_POD<int*const>::value)
value_test(true, is_POD<const int>::value)
// Steve: was 'false', should be 'true', via 3.9p10
value_test(true, is_POD<volatile int>::value)
// Steve: was 'true', should be 'false', via 3.9p10
value_test(false, is_POD<const int&>::value)
value_test(true, is_POD<int[2]>::value)
value_test(true, is_POD<int[3][2]>::value)
value_test(true, is_POD<int[2][4][5][6][3]>::value)
value_test(true, is_POD<f1>::value)
value_test(true, is_POD<mf2>::value)
value_test(false, is_POD<UDT>::value)
value_test(false, is_POD<empty_UDT>::value)
value_test(true, is_POD<enum_UDT>::value)
value_test(true, (boost::is_convertible<implicitly_convertible_to_int,
int>::value));
value_test(true, (boost::is_convertible<Derived,Base>::value));
value_test(true, (boost::is_convertible<Derived,Derived>::value));
value_test(true, (boost::is_convertible<Base,Base>::value));
value_test(false, (boost::is_convertible<Base,Derived>::value));
value_test(true, (boost::is_convertible<Derived,Derived>::value));
value_test(false, (boost::is_convertible<NonDerived,Base>::value));
value_test(false, (boost::is_convertible<boost::noncopyable, int>::value));
value_test(true, (boost::is_convertible<float,int>::value));
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
value_test(false, (boost::is_convertible<float,void>::value));
value_test(false, (boost::is_convertible<void,float>::value));
value_test(true, (boost::is_convertible<void,void>::value));
#endif
value_test(true, (boost::is_convertible<enum1, int>::value));
value_test(true, (boost::is_convertible<Derived*, Base*>::value));
value_test(false, (boost::is_convertible<Base*, Derived*>::value));
value_test(true, (boost::is_convertible<Derived&, Base&>::value));
value_test(false, (boost::is_convertible<Base&, Derived&>::value));
value_test(true, (boost::is_convertible<const Derived*, const Base*>::value));
value_test(false, (boost::is_convertible<const Base*, const Derived*>::value));
value_test(true, (boost::is_convertible<const Derived&, const Base&>::value));
value_test(false, (boost::is_convertible<const Base&, const Derived&>::value));
value_test(false, (boost::is_convertible<const int *, int*>::value));
value_test(false, (boost::is_convertible<const int&, int&>::value));
value_test(true, (boost::is_convertible<int*, int[2]>::value));
value_test(false, (boost::is_convertible<const int*, int[3]>::value));
value_test(true, (boost::is_convertible<const int&, int>::value));
value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
value_test(true, (boost::is_convertible<int *, const int*>::value));
value_test(true, (boost::is_convertible<int&, const int&>::value));
value_test(true, (boost::is_convertible<int[2], int*>::value));
value_test(true, (boost::is_convertible<int[2], const int*>::value));
value_test(false, (boost::is_convertible<const int[2], int*>::value));
align_test(int);
align_test(char);
align_test(double);
align_test(int[4]);
align_test(int(*)(int));
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
align_test(char&);
align_test(char (&)(int));
align_test(char(&)[4]);
#endif
align_test(int*);
//align_test(const int);
align_test(VB);
align_test(VD);
std::cout << std::endl << test_count << " tests completed (" << failures << " failures)";
return failures;
}
Reference in New Issue View Git Blame Copy Permalink