Moved pointer parameter

[SVN r9348]

iterator_adaptor_test.cpp

@@ -0,0 +1,463 @@
+//  Demonstrate and test boost/operators.hpp on std::iterators  -------------//
+
+//  (C) Copyright Jeremy Siek 1999. 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.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
+//            on MSVC. Hack around an MSVC-with-STLport internal compiler
+//            error. (David Abrahams)
+//  11 Feb 01 Added test of operator-> for forward and input iterators.
+//            (Jeremy Siek)
+//  11 Feb 01 Borland fixes (David Abrahams)
+//  10 Feb 01 Use new adaptors interface. (David Abrahams)
+//  10 Feb 01 Use new filter_ interface. (David Abrahams)
+//  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
+//            BOOST_NO_STD_ITERATOR_TRAITS with
+//            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
+//            normalized to core compiler capabilities (David Abrahams)
+//  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
+//            comprehensive testing. Force-decay array function arguments to
+//            pointers.
+//  07 Feb 01 Added tests for the make_xxx_iterator() helper functions.
+//            (Jeremy Siek)
+//  07 Feb 01 Replaced use of xxx_pair_generator with xxx_generator where
+//            possible (which was all but the projection iterator).
+//            (Jeremy Siek)
+//  06 Feb 01 Removed now-defaulted template arguments where possible
+//            Updated names to correspond to new generator naming convention.
+//            Added a trivial test for make_transform_iterator().
+//            Gave traits for const iterators a mutable value_type, per std.
+//            Resurrected my original tests for indirect iterators.
+//            (David Abrahams)
+//  04 Feb 01 Fix for compilers without standard iterator_traits
+//            (David Abrahams)
+//  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
+//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+
+#include <algorithm>
+#include <functional>
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/pending/integer_range.hpp>
+#include <boost/concept_archetype.hpp>
+#include <stdlib.h>
+#include <vector>
+#include <deque>
+#include <set>
+
+struct my_iterator_tag : public std::random_access_iterator_tag { };
+
+using boost::dummyT;
+
+struct my_iter_traits {
+  typedef dummyT value_type;
+  typedef dummyT* pointer;
+  typedef dummyT& reference;
+  typedef my_iterator_tag iterator_category;
+  typedef std::ptrdiff_t difference_type;
+};
+
+struct my_const_iter_traits {
+  typedef dummyT value_type;
+  typedef const dummyT* pointer;
+  typedef const dummyT& reference;
+  typedef my_iterator_tag iterator_category;
+  typedef std::ptrdiff_t difference_type;
+};
+
+typedef boost::iterator_adaptor<dummyT*, 
+  boost::default_iterator_policies, dummyT> my_iterator;
+
+typedef boost::iterator_adaptor<const dummyT*, 
+  boost::default_iterator_policies, const dummyT> const_my_iterator;
+
+
+struct mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+template <class Pair>
+struct select1st_ 
+  : public std::unary_function<Pair, typename Pair::first_type>
+{
+  const typename Pair::first_type& operator()(const Pair& x) const {
+    return x.first;
+  }
+  typename Pair::first_type& operator()(Pair& x) const {
+    return x.first;
+  }
+};
+
+struct one_or_four {
+  bool operator()(dummyT x) const {
+    return x.foo() == 1 || x.foo() == 4;
+  }
+};
+
+typedef std::deque<int> storage;
+typedef std::deque<int*> pointer_deque;
+typedef std::set<storage::iterator> iterator_set;
+
+void more_indirect_iterator_tests()
+{
+// For some reason all heck breaks loose in the compiler under these conditions.
+#if !defined(BOOST_MSVC) || !defined(__STL_DEBUG)
+    storage store(1000);
+    std::generate(store.begin(), store.end(), rand);
+    
+    pointer_deque ptr_deque;
+    iterator_set iter_set;
+
+    for (storage::iterator p = store.begin(); p != store.end(); ++p)
+    {
+        ptr_deque.push_back(&*p);
+        iter_set.insert(p);
+    }
+
+    typedef boost::indirect_iterator_pair_generator<
+        pointer_deque::iterator
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , int
+#endif
+    > IndirectDeque;
+
+    IndirectDeque::iterator db(ptr_deque.begin());
+    IndirectDeque::iterator de(ptr_deque.end());
+    assert(static_cast<std::size_t>(de - db) == store.size());
+    assert(db + store.size() == de);
+    IndirectDeque::const_iterator dci(db);
+    assert(db == dci);
+    assert(dci == db);
+    assert(dci != de);
+    assert(dci < de);
+    assert(dci <= de);
+    assert(de >= dci);
+    assert(de > dci);
+    dci = de;
+    assert(dci == de);
+
+    boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
+    
+    *db = 999;
+    assert(store.front() == 999);
+
+    typedef boost::indirect_iterator_generator<
+        iterator_set::iterator
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , int
+#endif
+        >::type indirect_set_iterator;
+
+    typedef boost::indirect_iterator_generator<
+        iterator_set::iterator,
+        const int
+        >::type const_indirect_set_iterator;
+
+    indirect_set_iterator sb(iter_set.begin());
+    indirect_set_iterator se(iter_set.end());
+    const_indirect_set_iterator sci(iter_set.begin());
+    assert(sci == sb);
+    assert(sci != se);
+    sci = se;
+    assert(sci == se);
+    
+    *boost::prior(se) = 888;
+    assert(store.back() == 888);
+    assert(std::equal(sb, se, store.begin()));
+
+    boost::bidirectional_iterator_test(boost::next(sb), store[1], store[2]);
+    assert(std::equal(db, de, store.begin()));
+#endif    
+}
+
+int
+main()
+{
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+                     dummyT(3), dummyT(4), dummyT(5) };
+  const int N = sizeof(array)/sizeof(dummyT);
+
+  // sanity check, if this doesn't pass the test is buggy
+  boost::random_access_iterator_test(array,N,array);
+
+  // Check that the policy concept checks and the default policy
+  // implementation match up.
+  boost::function_requires< 
+     boost::RandomAccessIteratorPoliciesConcept<
+       boost::default_iterator_policies, int*,
+       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
+                      int*, int&>
+      > >();
+
+  // Test the iterator_adaptor
+  {
+    my_iterator i(array);
+    boost::random_access_iterator_test(i, N, array);
+    
+    const_my_iterator j(array);
+    boost::random_access_iterator_test(j, N, array);
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test transform_iterator
+  {
+    int x[N], y[N];
+    for (int k = 0; k < N; ++k)
+      x[k] = k;
+    std::copy(x, x + N, y);
+
+    for (int k2 = 0; k2 < N; ++k2)
+      x[k2] = x[k2] * 2;
+
+    boost::transform_iterator_generator<mult_functor, int*>::type
+      i(y, mult_functor(2));
+    boost::input_iterator_test(i, x[0], x[1]);
+    boost::input_iterator_test(boost::make_transform_iterator(&y[0], mult_functor(2)), x[0], x[1]);
+  }
+  
+  // Test indirect_iterator_generator
+  {
+    dummyT* ptr[N];
+    for (int k = 0; k < N; ++k)
+      ptr[k] = array + k;
+
+    typedef boost::indirect_iterator_generator<dummyT**
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+      >::type indirect_iterator;
+
+    typedef boost::indirect_iterator_generator<dummyT**, const dummyT>::type const_indirect_iterator;
+
+    indirect_iterator i(ptr);
+    boost::random_access_iterator_test(i, N, array);
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
+#endif
+    
+    // check operator->
+    assert((*i).m_x == i->foo());
+
+    const_indirect_iterator j(ptr);
+    boost::random_access_iterator_test(j, N, array);
+
+    dummyT*const* const_ptr = ptr;
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
+#endif
+    boost::const_nonconst_iterator_test(i, ++j);
+
+    more_indirect_iterator_tests();
+  }
+
+  // Test projection_iterator_pair_generator
+  {    
+    typedef std::pair<dummyT,dummyT> Pair;
+    Pair pair_array[N];
+    for (int k = 0; k < N; ++k)
+      pair_array[k].first = array[k];
+
+    typedef boost::projection_iterator_pair_generator<select1st_<Pair>,
+      Pair*, const Pair*
+      > Projection;
+    
+    Projection::iterator i(pair_array);
+    boost::random_access_iterator_test(i, N, array);
+
+    boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
+    boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
+
+    Projection::const_iterator j(pair_array);
+    boost::random_access_iterator_test(j, N, array);
+
+    boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
+    boost::random_access_iterator_test(boost::make_const_projection_iterator<select1st_<Pair> >(pair_array), N, array);
+
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test reverse_iterator_generator
+  {
+    dummyT reversed[N];
+    std::copy(array, array + N, reversed);
+    std::reverse(reversed, reversed + N);
+    
+    typedef boost::reverse_iterator_generator<dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+      >::type reverse_iterator;
+    
+    reverse_iterator i(reversed + N);
+    boost::random_access_iterator_test(i, N, array);
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+#endif
+
+    typedef boost::reverse_iterator_generator<const dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , const dummyT
+#endif
+      >::type const_reverse_iterator;
+    
+    const_reverse_iterator j(reversed + N);
+    boost::random_access_iterator_test(j, N, array);
+
+    const dummyT* const_reversed = reversed;
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+#endif
+    
+    boost::const_nonconst_iterator_test(i, ++j);    
+  }
+
+  // Test reverse_iterator_generator again, with traits fully deducible on all platforms
+  {
+    std::deque<dummyT> reversed_container;
+    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
+    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
+
+
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::iterator>::type reverse_iterator;
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
+
+    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
+    // (e.g. "reversed + N") is used in the constructor below.
+    const std::deque<dummyT>::iterator finish = reversed_container.end();
+    reverse_iterator i(finish);
+    
+    boost::random_access_iterator_test(i, N, array);
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+
+    const_reverse_iterator j = reverse_iterator(finish);
+    boost::random_access_iterator_test(j, N, array);
+
+    const std::deque<dummyT>::const_iterator const_reversed = reversed;
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+    
+    // Many compilers' builtin deque iterators don't interoperate well, though
+    // STLport fixes that problem.
+#if defined(__SGI_STL_PORT) || !defined(__GNUC__) && !defined(__BORLANDC__) && !defined(BOOST_MSVC)
+    boost::const_nonconst_iterator_test(i, ++j);
+#endif
+  }
+  
+  // Test integer_range's iterators
+  {
+    int int_array[] = { 0, 1, 2, 3, 4, 5 };
+    boost::integer_range<int> r(0, 5);
+    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
+  }
+
+  // Test filter iterator
+  {
+    // Using typedefs for filter_gen::type and filter_gen::policies_type
+    // confused Borland terribly.
+    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
+    
+    typedef ::boost::filter_iterator_generator<one_or_four, dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+        > filter_iter_gen;
+
+#ifndef __BORLANDC__
+    typedef filter_iter_gen::type filter_iter;
+#else
+# define filter_iter filter_iter_gen::type // Borland has a problem with the above
+#endif
+    filter_iter i(array, filter_iter::policies_type(one_or_four(), array + N));
+    boost::forward_iterator_test(i, dummyT(1), dummyT(4));
+
+    enum { is_forward = boost::is_same<
+           filter_iter::iterator_category,
+           std::forward_iterator_tag>::value };
+    BOOST_STATIC_ASSERT(is_forward);
+
+    // On compilers not supporting partial specialization, we can do more type
+    // deduction with deque iterators than with pointers... unless the library
+    // is broken ;-(
+#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+    std::deque<dummyT> array2;
+    std::copy(array+0, array+N, std::back_inserter(array2));
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
+        dummyT(1), dummyT(4));
+#endif
+
+#if !defined(BOOST_MSVC) // This just freaks MSVC out completely
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(
+            boost::make_reverse_iterator(array2.end()),
+            boost::make_reverse_iterator(array2.begin())
+            ),
+        dummyT(4), dummyT(1));
+#endif
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array+0, array+N, one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array, array + N),
+        dummyT(1), dummyT(4));
+
+#endif
+  }
+
+  // check operator-> with a forward iterator
+  {
+    boost::forward_iterator_archetype<dummyT> forward_iter;
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, 
+      std::forward_iterator_tag, std::ptrdiff_t, const dummyT*> adaptor_type;
+    adaptor_type i(forward_iter);
+    if (0) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+  // check operator-> with an input iterator
+  {
+    boost::input_iterator_archetype<dummyT> input_iter;
+    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, 
+      std::input_iterator_tag, std::ptrdiff_t, const dummyT*> adaptor_type;
+    adaptor_type i(input_iter);
+    if (0) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+
+  std::cout << "test successful " << std::endl;
+  return 0;
+}

type_traits_test.cpp

@@ -1,659 +0,0 @@
-//  (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:
-   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 Deriverd : 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;
-};
-
-// 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()
-{
-   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)
-
-   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<Deriverd,Base>::value));
-   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
-   value_test(true, (boost::is_convertible<Base,Base>::value));
-   value_test(false, (boost::is_convertible<Base,Deriverd>::value));
-   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::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<Deriverd*, Base*>::value));
-   value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
-   value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
-   value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
-   value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
-   value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
-   value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
-   value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::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;
-}
-
-
-
-