This commit was manufactured by cvs2svn to create tag

'Version_1_33_1_beta'.

[SVN r31604]

MultiPassInputIterator.html

@@ -30,9 +30,9 @@ adding the requirements that the iterator can be used to make multiple
 passes through a range, and that if <TT>it1 == it2</TT> and
 <TT>it1</TT> is dereferenceable then <TT>++it1 == ++it2</TT>. The
 Multi-Pass Input Iterator is very similar to the <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.hmtl">Forward Iterator</a>. The
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>. The
 only difference is that a <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.hmtl">Forward Iterator</a>
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
 requires the <TT>reference</TT> type to be <TT>value_type&amp;</TT>, whereas
 MultiPassInputIterator is like <a
 href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>

addressof_test.cpp

@@ -7,35 +7,88 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/utility.hpp>
+
+#include <boost/utility/addressof.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+template<class T> void scalar_test( T * = 0 )
+{
+    T* px = new T();
+
+    T& x = *px;
+    BOOST_TEST( boost::addressof(x) == px );
+
+    const T& cx = *px;
+    const T* pcx = boost::addressof(cx);
+    BOOST_TEST( pcx == px );
+
+    volatile T& vx = *px;
+    volatile T* pvx = boost::addressof(vx);
+    BOOST_TEST( pvx == px );
+
+    const volatile T& cvx = *px;
+    const volatile T* pcvx = boost::addressof(cvx);
+    BOOST_TEST( pcvx == px );
+
+    delete px;
+}
+
+template<class T> void array_test( T * = 0 )
+{
+    T nrg[3] = {1,2,3};
+    T (*pnrg)[3] = &nrg;
+    BOOST_TEST( boost::addressof(nrg) == pnrg );
+
+    T const cnrg[3] = {1,2,3};
+    T const (*pcnrg)[3] = &cnrg;
+    BOOST_TEST( boost::addressof(cnrg) == pcnrg );
+}
+
+struct addressable
+{
+    addressable( int = 0 )
+    {
+    }
+};
 
 struct useless_type {};
 
 class nonaddressable {
 public:
-  void dummy(); // Silence GCC warning: all member of class are private
+
+    nonaddressable( int = 0 )
+    {
+    }
+
+    void dummy(); // Silence GCC warning: all member of class are private
 
 private:
-  useless_type operator&() const;
+
+    useless_type operator&() const;
 };
 
-int test_main(int, char*[])
+int main()
 {
-  nonaddressable* px = new nonaddressable();
+    scalar_test<char>();
+    scalar_test<int>();
+    scalar_test<addressable>();
+    scalar_test<nonaddressable>();
 
-  nonaddressable& x = *px;
-  BOOST_TEST(boost::addressof(x) == px);
+    array_test<char>();
+    array_test<int>();
+    array_test<addressable>();
+    array_test<nonaddressable>();
 
-  const nonaddressable& cx = *px;
-  BOOST_TEST(boost::addressof(cx) == static_cast<const nonaddressable*>(px));
-
-  volatile nonaddressable& vx = *px;
-  BOOST_TEST(boost::addressof(vx) == static_cast<volatile nonaddressable*>(px));
-
-  const volatile nonaddressable& cvx = *px;
-  BOOST_TEST(boost::addressof(cvx) == static_cast<const volatile nonaddressable*>(px));
-  
-  return 0;
+    return boost::report_errors();
 }

call_traits_test.cpp

@@ -19,7 +19,42 @@
 #include <typeinfo>
 #include <boost/call_traits.hpp>
 
-#include <boost/type_traits/type_traits_test.hpp>
+#include <libs/type_traits/test/test.hpp>
+#include <libs/type_traits/test/check_type.hpp>
+
+//
+// define tests here
+unsigned failures = 0;
+unsigned test_count = 0;
+//
+// This must get defined within the test file.
+// All compilers have bugs, set this to the number of
+// regressions *expected* from a given compiler,
+// if there are no workarounds for the bugs, *and*
+// the regressions have been investigated.
+//
+extern unsigned int expected_failures;
+//
+// proc check_result()
+// Checks that there were no regressions:
+//
+int check_result(int argc, char** argv)
+{
+   std::cout << test_count << " tests completed, "
+      << failures << " failures found, "
+      << expected_failures << " failures expected from this compiler." << std::endl;
+   if((argc == 2) 
+      && (argv[1][0] == '-')
+      && (argv[1][1] == 'a')
+      && (argv[1][2] == 0))
+   {
+      std::cout << "Press any key to continue...";
+      std::cin.get();
+   }
+   return (failures == expected_failures)
+       ? 0
+       : (failures != 0) ? static_cast<int>(failures) : -1;
+}
 
 // a way prevent warnings for unused variables
 template<class T> inline void unused_variable(const T&) {}
@@ -231,51 +266,51 @@ int main(int argc, char *argv[ ])
    typedef int& r_type;
    typedef const r_type cr_type;
 
-   type_test(comparible_UDT, boost::call_traits<comparible_UDT>::value_type)
-   type_test(comparible_UDT&, boost::call_traits<comparible_UDT>::reference)
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference)
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type)
-   type_test(int, boost::call_traits<int>::value_type)
-   type_test(int&, boost::call_traits<int>::reference)
-   type_test(const int&, boost::call_traits<int>::const_reference)
-   type_test(const int, boost::call_traits<int>::param_type)
-   type_test(int*, boost::call_traits<int*>::value_type)
-   type_test(int*&, boost::call_traits<int*>::reference)
-   type_test(int*const&, boost::call_traits<int*>::const_reference)
-   type_test(int*const, boost::call_traits<int*>::param_type)
+   BOOST_CHECK_TYPE(comparible_UDT, boost::call_traits<comparible_UDT>::value_type);
+   BOOST_CHECK_TYPE(comparible_UDT&, boost::call_traits<comparible_UDT>::reference);
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference);
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type);
+   BOOST_CHECK_TYPE(int, boost::call_traits<int>::value_type);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<int>::const_reference);
+   BOOST_CHECK_TYPE(const int, boost::call_traits<int>::param_type);
+   BOOST_CHECK_TYPE(int*, boost::call_traits<int*>::value_type);
+   BOOST_CHECK_TYPE(int*&, boost::call_traits<int*>::reference);
+   BOOST_CHECK_TYPE(int*const&, boost::call_traits<int*>::const_reference);
+   BOOST_CHECK_TYPE(int*const, boost::call_traits<int*>::param_type);
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-   type_test(int&, boost::call_traits<int&>::value_type)
-   type_test(int&, boost::call_traits<int&>::reference)
-   type_test(const int&, boost::call_traits<int&>::const_reference)
-   type_test(int&, boost::call_traits<int&>::param_type)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::value_type);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<int&>::const_reference);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::param_type);
 #if !(defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)))
-   type_test(int&, boost::call_traits<cr_type>::value_type)
-   type_test(int&, boost::call_traits<cr_type>::reference)
-   type_test(const int&, boost::call_traits<cr_type>::const_reference)
-   type_test(int&, boost::call_traits<cr_type>::param_type)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::value_type);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<cr_type>::const_reference);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::param_type);
 #else
    std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
    failures += 4;
    test_count += 4;
 #endif
-   type_test(const int&, boost::call_traits<const int&>::value_type)
-   type_test(const int&, boost::call_traits<const int&>::reference)
-   type_test(const int&, boost::call_traits<const int&>::const_reference)
-   type_test(const int&, boost::call_traits<const int&>::param_type)
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::value_type);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::const_reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::param_type);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   type_test(const int*, boost::call_traits<int[3]>::value_type)
-   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<int[3]>::param_type)
-   type_test(const int*, boost::call_traits<const int[3]>::value_type)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<const int[3]>::param_type)
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<int[3]>::value_type);
+   BOOST_CHECK_TYPE(int(&)[3], boost::call_traits<int[3]>::reference);
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<int[3]>::const_reference);
+   BOOST_CHECK_TYPE(const int*const, boost::call_traits<int[3]>::param_type);
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<const int[3]>::value_type);
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::reference);
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::const_reference);
+   BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type);
    // test with abstract base class:
-   type_test(test_abc1, boost::call_traits<test_abc1>::value_type)
-   type_test(test_abc1&, boost::call_traits<test_abc1>::reference)
-   type_test(const test_abc1&, boost::call_traits<test_abc1>::const_reference)
-   type_test(const test_abc1&, boost::call_traits<test_abc1>::param_type)
+   BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
+   BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
+   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
+   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
 #else
    std::cout << "You're compiler does not support partial template specialiation, skipping 8 tests (8 errors)" << std::endl;
    failures += 12;
@@ -287,10 +322,10 @@ int main(int argc, char *argv[ ])
    test_count += 24;
 #endif
    // test with an incomplete type:
-   type_test(incomplete_type, boost::call_traits<incomplete_type>::value_type)
-   type_test(incomplete_type&, boost::call_traits<incomplete_type>::reference)
-   type_test(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference)
-   type_test(const incomplete_type&, boost::call_traits<incomplete_type>::param_type)
+   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
+   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
+   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
+   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
 
    return check_result(argc, argv);
 }
@@ -410,7 +445,7 @@ template struct call_traits_test<int[2], true>;
 #endif
 
 #if defined(BOOST_MSVC) && _MSC_VER <= 1300
-unsigned int expected_failures = 14;
+unsigned int expected_failures = 12;
 #elif defined(__SUNPRO_CC)
 #if(__SUNPRO_CC <= 0x520)
 unsigned int expected_failures = 18;

compressed_pair.htm

@@ -1,30 +1,19 @@
 <html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Header </title>
-<boost/compressed_pair.hpp>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
-vlink="#800080">
-
-<h2><img src="../../boost.png" width="276" height="86">Header
-&lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
-
-<p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are
-defined inside namespace boost.</p>
-
-<p>The class compressed pair is very similar to std::pair, but if
-either of the template arguments are empty classes, then the
-&quot;empty base-class optimisation&quot; is applied to compress
-the size of the pair.</p>
-
-<pre>template &lt;class T1, class T2&gt;
+   <head>
+      <title>Header </title>
+      <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+      <meta name="Template" content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
+      <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
+      <boostcompressed_pair.hpp>
+   </head>
+   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
+      <h2><img src="../../boost.png" width="276" height="86">Header &lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
+      <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are defined inside 
+         namespace boost.</p>
+      <p>The class compressed pair is very similar to std::pair, but if either of the 
+         template arguments are empty classes, then the "empty base-class optimisation" 
+         is applied to compress the size of the pair.</p>
+      <pre>template &lt;class T1, class T2&gt;
 class compressed_pair
 {
 public:
@@ -52,47 +41,35 @@ public:
 
 	void swap(compressed_pair&amp; y);
 };</pre>
-
-<p>The two members of the pair can be accessed using the member
-functions first() and second(). Note that not all member
-functions can be instantiated for all template parameter types.
-In particular compressed_pair can be instantiated for reference
-and array types, however in these cases the range of constructors
-that can be used are limited. If types T1 and T2 are the same
-type, then there is only one version of the single-argument
-constructor, and this constructor initialises both values in the
-pair to the passed value.</p>
-
-<p>Note that compressed_pair can not be instantiated if either of
-the template arguments is a union type, unless there is compiler
-support for boost::is_union, or if boost::is_union is specialised
-for the union type.</p>
-
-<p>Finally, a word of caution for Visual C++ 6 users: if either
-argument is an empty type, then assigning to that member will
-produce memory corruption, unless the empty type has a &quot;do
-nothing&quot; assignment operator defined. This is due to a bug
-in the way VC6 generates implicit assignment operators.</p>
-
-<hr>
-
-<p>Revised 08 May 2001</p>
-
-<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
-sell and distribute this document is granted provided this
-copyright notice appears in all copies. This document is provided
-&quot;as is&quot; without express or implied warranty, and with
-no claim as to its suitability for any purpose.</p>
-
-<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
-Hinnant and John Maddock.</p>
-
-<p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John
-Maddock</a>, the latest version of this file can be found at <a
-href="http://www.boost.org">www.boost.org</a>, and the boost
-discussion list at <a
-href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>
-
-<p>&nbsp;</p>
-</body>
+      <p>The two members of the pair can be accessed using the member functions first() 
+         and second(). Note that not all member functions can be instantiated for all 
+         template parameter types. In particular compressed_pair can be instantiated for 
+         reference and array types, however in these cases the range of constructors 
+         that can be used are limited. If types T1 and T2 are the same type, then there 
+         is only one version of the single-argument constructor, and this constructor 
+         initialises both values in the pair to the passed value.</p>
+      <P>Note that if either member is a POD type, then that member is not 
+         zero-initialized by the compressed_pair default constructor: it's up to you to 
+         supply an initial value for these types if you want them to have a default 
+         value.</P>
+      <p>Note that compressed_pair can not be instantiated if either of the template 
+         arguments is a union type, unless there is compiler support for 
+         boost::is_union, or if boost::is_union is specialised for the union type.</p>
+      <p>Finally, a word of caution for Visual C++ 6 users: if either argument is an 
+         empty type, then assigning to that member will produce memory corruption, 
+         unless the empty type has a "do nothing" assignment operator defined. This is 
+         due to a bug in the way VC6 generates implicit assignment operators.</p>
+      <hr>
+      <p>Revised 08 May 2001</p>
+      <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify, sell and 
+         distribute this document is granted provided this copyright notice appears in 
+         all copies. This document is provided "as is" without express or implied 
+         warranty, and with no claim as to its suitability for any purpose.</p>
+      <p>Based on contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John 
+         Maddock.</p>
+      <p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John Maddock</a>, the 
+         latest version of this file can be found at <a href="http://www.boost.org">www.boost.org</a>, 
+         and the boost discussion list at <a href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>
+      <p>&nbsp;</p>
+   </body>
 </html>

compressed_pair_test.cpp

@@ -14,29 +14,23 @@
 #include <cassert>
 
 #include <boost/compressed_pair.hpp>
-#include <boost/type_traits/type_traits_test.hpp>
-#define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 
 using namespace boost;
 
-namespace boost {
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template <> struct is_empty<empty_UDT>
-{ static const bool value = true; };
-template <> struct is_empty<empty_POD_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<empty_POD_UDT>
-{ static const bool value = true; };
-#else
-template <> struct is_empty<empty_UDT>
-{ enum{ value = true }; };
-template <> struct is_empty<empty_POD_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<empty_POD_UDT>
-{ enum{ value = true }; };
-#endif
-}
+struct empty_UDT
+{
+   ~empty_UDT(){};
+   empty_UDT& operator=(const empty_UDT&){ return *this; }
+   bool operator==(const empty_UDT&)const
+   { return true; }
+};
+struct empty_POD_UDT
+{
+   empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
+   bool operator==(const empty_POD_UDT&)const
+   { return true; }
+};
 
 struct non_empty1
 { 
@@ -85,47 +79,47 @@ void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type
    // first param construct:
    boost::compressed_pair<T1,T2> cp2(p1);
    cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second() == p2);
    // second param construct:
    boost::compressed_pair<T1,T2> cp3(p2);
    cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first() == p1);
    // both param construct:
    boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
    boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second() == p2);
 
    // copy construct:
    boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.first() == p1);
+   BOOST_CHECK(cp6.second() == p2);
    // assignment:
    cp1 = cp4;
-   BOOST_TEST(cp1.first() == p1);
-   BOOST_TEST(cp1.second() == p2);
+   BOOST_CHECK(cp1.first() == p1);
+   BOOST_CHECK(cp1.second() == p2);
    cp1 = cp5;
-   BOOST_TEST(cp1.first() == p3);
-   BOOST_TEST(cp1.second() == p4);
+   BOOST_CHECK(cp1.first() == p3);
+   BOOST_CHECK(cp1.second() == p4);
    // swap:
    cp4.swap(cp5);
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
-   BOOST_TEST(cp5.first() == p1);
-   BOOST_TEST(cp5.second() == p2);
+   BOOST_CHECK(cp4.first() == p3);
+   BOOST_CHECK(cp4.second() == p4);
+   BOOST_CHECK(cp5.first() == p1);
+   BOOST_CHECK(cp5.second() == p2);
    swap(cp4,cp5);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
 }
 
 //
@@ -154,20 +148,20 @@ void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_
 #endif
    // both param construct:
    boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
    boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second() == p2);
 
    // copy construct:
    boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.first() == p1);
+   BOOST_CHECK(cp6.second() == p2);
    // assignment:
    // VC6 bug:
    // When second() is an empty class, VC6 performs the
@@ -180,8 +174,8 @@ void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_
    // settings - some generate the problem others do not.
    cp4.first() = p3;
    cp4.second() = p4;
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
+   BOOST_CHECK(cp4.first() == p3);
+   BOOST_CHECK(cp4.second() == p4);
 }
 //
 // supplimentary tests for case where first arg only is a reference type:
@@ -205,8 +199,8 @@ void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second
    // first param construct:
    boost::compressed_pair<T1,T2> cp2(p1);
    cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second() == p2);
 #endif
 }
 //
@@ -231,8 +225,8 @@ void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second
    // second param construct:
    boost::compressed_pair<T1,T2> cp3(p2);
    cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first() == p1);
 #endif
 }
 
@@ -259,14 +253,14 @@ void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_par
    // second param construct:
    boost::compressed_pair<T1,T2> cp3(p2);
    cp3.first()[0] = p1[0];
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first()[0] == p1[0]);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first()[0] == p1[0]);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp3;
-   BOOST_TEST(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first()[0] == p1[0]);
+   BOOST_CHECK(cpr1.second() == p2);
 
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
 }
 
 template <class T1, class T2>
@@ -289,14 +283,14 @@ void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_par
    // first param construct:
    boost::compressed_pair<T1,T2> cp2(p1);
    cp2.second()[0] = p2[0];
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second()[0] == p2[0]);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second()[0] == p2[0]);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp2;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);
 
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 
 template <class T1, class T2>
@@ -318,15 +312,15 @@ void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_para
    boost::compressed_pair<T1,T2> cp1;
    cp1.first()[0] = p1[0];
    cp1.second()[0] = p2[0];
-   BOOST_TEST(cp1.first()[0] == p1[0]);
-   BOOST_TEST(cp1.second()[0] == p2[0]);
+   BOOST_CHECK(cp1.first()[0] == p1[0]);
+   BOOST_CHECK(cp1.second()[0] == p2[0]);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp1;
-   BOOST_TEST(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
+   BOOST_CHECK(cpr1.first()[0] == p1[0]);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);
 
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 
 int test_main(int, char *[])

enable_if/test/Jamfile.v2

@@ -0,0 +1,23 @@
+# Copyright David Abrahams 2003.
+# Distributed under the Boost Software License, Version 1.0. 
+# (See accompanying file LICENSE_1_0.txt or copy at 
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# For more information, see http://www.boost.org/
+
+project
+    : requirements <library>/boost/test//boost_test_exec_monitor
+    ;
+
+test-suite utility/enable_if
+        :
+        [ run constructors.cpp ]
+        [ run dummy_arg_disambiguation.cpp ]
+        [ run lazy.cpp ]
+        [ run lazy_test.cpp ]
+        [ run member_templates.cpp ]
+        [ run namespace_disambiguation.cpp ]
+        [ run no_disambiguation.cpp ]
+        [ run partial_specializations.cpp ]
+    ;
+

generator_iterator.htm

@@ -58,7 +58,7 @@ template <class Generator>
 class generator_iterator_generator
 {
 public:
-  typedef <a href="iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt; type; // the resulting generator iterator type 
+  typedef <i>unspecified</i> type; // the resulting generator iterator type 
 }
 </pre>
 

in_place_factories.html

@@ -117,9 +117,6 @@ From the user POV, it amounts to creating the right factory object to hold the p
 The following simplified example shows the basic idea. A complete example follows the formal specification of the framework:</p>
 <pre>struct C
 {
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-
    template&lt;class InPlaceFactory&gt;
    C ( InPlaceFactory const& aFactoty )
     :
@@ -128,11 +125,15 @@ The following simplified example shows the basic idea. A complete example follow
      aFactory.template apply&lt;X&gt;(contained_);
    }
 
-  ~C() { delete contained_ ; }
+  ~C() 
+  { 
+    contained_ -> X::~X();
+    delete[] contained_ ; 
+  }
 
-  X* uninitialized_storage() { return static_cast&lt;X*&gt;(new char[sizeof(X)]) ; }
+  char* uninitialized_storage() { return new char[sizeof(X)] ; }
 
-  X* contained_ ;
+  char* contained_ ;
 } ;
 
 void foo()

include/boost/assert.hpp

@@ -32,6 +32,6 @@ void assertion_failed(char const * expr, char const * function, char const * fil
 #define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
 #else
-# include <assert.h>
+# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif

include/boost/detail/call_traits.hpp

@@ -25,6 +25,7 @@
 
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_pointer.hpp>
+#include <boost/detail/workaround.hpp>
 
 namespace boost{
 
@@ -91,7 +92,7 @@ struct call_traits<T&>
    typedef T& param_type;  // hh removed const
 };
 
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
+#if BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT( 0x570 ) )
 // these are illegal specialisations; cv-qualifies applied to
 // references have no effect according to [8.3.2p1],
 // C++ Builder requires them though as it treats cv-qualified

include/boost/detail/compressed_pair.hpp

@@ -132,7 +132,7 @@ namespace details
 
    template <class T1, class T2>
    class compressed_pair_imp<T1, T2, 1>
-      : private T1
+      : private ::boost::remove_cv<T1>::type
    {
    public:
       typedef T1                                                 first_type;
@@ -174,7 +174,7 @@ namespace details
 
    template <class T1, class T2>
    class compressed_pair_imp<T1, T2, 2>
-      : private T2
+      : private ::boost::remove_cv<T2>::type
    {
    public:
       typedef T1                                                 first_type;
@@ -217,8 +217,8 @@ namespace details
 
    template <class T1, class T2>
    class compressed_pair_imp<T1, T2, 3>
-      : private T1,
-        private T2
+      : private ::boost::remove_cv<T1>::type,
+        private ::boost::remove_cv<T2>::type
    {
    public:
       typedef T1                                                 first_type;
@@ -257,7 +257,7 @@ namespace details
    //      but reuses T1 base class for both first() and second().
    template <class T1, class T2>
    class compressed_pair_imp<T1, T2, 4>
-      : private T1
+      : private ::boost::remove_cv<T1>::type
    {
    public:
       typedef T1                                                 first_type;
@@ -430,5 +430,3 @@ swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
 
 #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
 
-
-

include/boost/operators.hpp

@@ -674,7 +674,7 @@ struct random_access_iteratable
 // Here's where we put it all together, defining the xxxx forms of the templates
 // in namespace boost. We also define specializations of is_chained_base<> for
 // the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
-// neccessary.
+// necessary.
 //
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
@@ -699,7 +699,7 @@ template<class T> struct is_chained_base {
 
 } // namespace boost
 
-// Import a 4-type-argument operator template into boost (if neccessary) and
+// Import a 4-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE4(template_name4)                     \
   BOOST_IMPORT_TEMPLATE4(template_name4)                              \
@@ -708,7 +708,7 @@ template<class T> struct is_chained_base {
     typedef ::boost::detail::true_t value;                            \
   };
 
-// Import a 3-type-argument operator template into boost (if neccessary) and
+// Import a 3-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
   BOOST_IMPORT_TEMPLATE3(template_name3)                              \
@@ -717,7 +717,7 @@ template<class T> struct is_chained_base {
     typedef ::boost::detail::true_t value;                            \
   };
 
-// Import a 2-type-argument operator template into boost (if neccessary) and
+// Import a 2-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
   BOOST_IMPORT_TEMPLATE2(template_name2)                           \
@@ -726,7 +726,7 @@ template<class T> struct is_chained_base {
     typedef ::boost::detail::true_t value;                         \
   };
 
-// Import a 1-type-argument operator template into boost (if neccessary) and
+// Import a 1-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
   BOOST_IMPORT_TEMPLATE1(template_name1)                           \

include/boost/utility/addressof.hpp

@@ -13,9 +13,6 @@
 
 # include <boost/config.hpp>
 # include <boost/detail/workaround.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-#  include <boost/type_traits/add_pointer.hpp>
-# endif
 
 namespace boost {
 
@@ -23,7 +20,14 @@ namespace boost {
 
 // VC7 strips const from nested classes unless we add indirection here
 # if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-template <typename T> typename add_pointer<T>::type
+
+template<class T> struct _addp
+{
+    typedef T * type;
+};
+    
+template <typename T> typename _addp<T>::type
+
 # else
 template <typename T> T*
 # endif
@@ -33,6 +37,22 @@ addressof(T& v)
        &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
 }
 
+// Borland doesn't like casting an array reference to a char reference
+// but these overloads work around the problem.
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template<typename T,std::size_t N>
+T (*addressof(T (&t)[N]))[N]
+{
+   return reinterpret_cast<T(*)[N]>(&t);
+}
+
+template<typename T,std::size_t N>
+const T (*addressof(const T (&t)[N]))[N]
+{
+   return reinterpret_cast<const T(*)[N]>(&t);
+}
+# endif
+
 }
 
 #endif // BOOST_UTILITY_ADDRESSOF_HPP

include/boost/utility/result_of.hpp

@@ -57,9 +57,10 @@ struct result_of : get_result_of<F, FArgs, (has_result_type<F>::value)> {};
 #define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
 #include BOOST_PP_ITERATE()
 
-}
 #else
-#  error Your compiler cannot support class template result_of
+#  define BOOST_NO_RESULT_OF 1
 #endif
 
+}
+
 #endif // BOOST_RESULT_OF_HPP

iterators_test.cpp

@@ -174,7 +174,7 @@ test_opr<T, R, P>::post_increment_test
         oss << *i++ << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple orange pear peach grape plum ");
+    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }
 
 // Test post-decrement
@@ -193,7 +193,7 @@ test_opr<T, R, P>::post_decrement_test
         oss << *i << ' ';
     }
 
-    BOOST_TEST( oss.str() == "plum grape peach pear orange apple ");
+    BOOST_CHECK( oss.str() == "plum grape peach pear orange apple ");
 }
 
 // Test indirect structure referral
@@ -211,7 +211,7 @@ test_opr<T, R, P>::indirect_referral_test
         oss << i->size() << ' ';
     }
 
-    BOOST_TEST( oss.str() == "5 6 4 5 5 4 ");
+    BOOST_CHECK( oss.str() == "5 6 4 5 5 4 ");
 }
 
 // Test offset addition
@@ -230,7 +230,7 @@ test_opr<T, R, P>::offset_addition_test
         oss << *i << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple pear grape ");
+    BOOST_CHECK( oss.str() == "apple pear grape ");
 }
 
 // Test offset addition, in reverse order
@@ -249,7 +249,7 @@ test_opr<T, R, P>::reverse_offset_addition_test
         oss << *i << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple pear grape ");
+    BOOST_CHECK( oss.str() == "apple pear grape ");
 }
 
 // Test offset subtraction
@@ -272,7 +272,7 @@ test_opr<T, R, P>::offset_subtraction_test
         }
     }
 
-    BOOST_TEST( oss.str() == "grape pear apple ");
+    BOOST_CHECK( oss.str() == "grape pear apple ");
 }
 
 // Test comparisons
@@ -296,10 +296,10 @@ test_opr<T, R, P>::comparison_test
         {
             ptrdiff_t const  j_offset = j - fruit_begin;
 
-            BOOST_TEST( (i != j) == (i_offset != j_offset) );
-            BOOST_TEST( (i > j) == (i_offset > j_offset) );
-            BOOST_TEST( (i <= j) == (i_offset <= j_offset) );
-            BOOST_TEST( (i >= j) == (i_offset >= j_offset) );
+            BOOST_CHECK( (i != j) == (i_offset != j_offset) );
+            BOOST_CHECK( (i > j) == (i_offset > j_offset) );
+            BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
+            BOOST_CHECK( (i >= j) == (i_offset >= j_offset) );
         }
     }
     cout << std::endl;
@@ -320,5 +320,5 @@ test_opr<T, R, P>::indexing_test
         oss << fruit_begin[ k ] << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple orange pear peach grape plum ");
+    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }

numeric_traits_test.cpp

@@ -57,7 +57,7 @@ struct complement
     struct traits
     {
      private:
-        // indirection through complement_traits_aux neccessary to keep MSVC happy
+        // indirection through complement_traits_aux necessary to keep MSVC happy
         typedef complement_traits_aux<Number, size - 1> prev;
      public:
         BOOST_STATIC_CONSTANT(Number, max =

operators_test.cpp

@@ -269,17 +269,17 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void sanity_check(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( true_value(y1) == true_value(y2) );
-        BOOST_TEST( true_value(x1) == true_value(x2) );
+        BOOST_CHECK( true_value(y1) == true_value(y2) );
+        BOOST_CHECK( true_value(x1) == true_value(x2) );
     }
 
     template <class X1, class Y1, class X2, class Y2>
     void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( (x1 < y1) == (x2 < y2) );
-        BOOST_TEST( (x1 <= y1) == (x2 <= y2) );
-        BOOST_TEST( (x1 >= y1) == (x2 >= y2) );
-        BOOST_TEST( (x1 > y1) == (x2 > y2) );
+        BOOST_CHECK( (x1 < y1) == (x2 < y2) );
+        BOOST_CHECK( (x1 <= y1) == (x2 <= y2) );
+        BOOST_CHECK( (x1 >= y1) == (x2 >= y2) );
+        BOOST_CHECK( (x1 > y1) == (x2 > y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -293,8 +293,8 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_equality_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( (x1 == y1) == (x2 == y2) );
-        BOOST_TEST( (x1 != y1) == (x2 != y2) );
+        BOOST_CHECK( (x1 == y1) == (x2 == y2) );
+        BOOST_CHECK( (x1 != y1) == (x2 != y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -308,7 +308,7 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_multipliable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( (x1 * y1).value() == (x2 * y2) );
+        BOOST_CHECK( (x1 * y1).value() == (x2 * y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -322,7 +322,7 @@ namespace
   template <class A, class B>
   void test_value_equality(A a, B b)
   {
-      BOOST_TEST(a.value() == b);
+      BOOST_CHECK(a.value() == b);
   }
   
 #define TEST_OP_R(op) test_value_equality(x1 op y1, x2 op y2)
@@ -448,16 +448,16 @@ namespace
     void test_incrementable(X1 x1, X2 x2)
     {
         sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1++).value() == x2++ );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( (x1++).value() == x2++ );
+        BOOST_CHECK( x1.value() == x2 );
     }
     
     template <class X1, class X2>
     void test_decrementable(X1 x1, X2 x2)
     {
         sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1--).value() == x2-- );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( (x1--).value() == x2-- );
+        BOOST_CHECK( x1.value() == x2 );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -561,7 +561,7 @@ template Wrapped6<unsigned long, unsigned char>;
 template Wrapped6<unsigned int, unsigned char>;
 #endif
 
-#define PRIVATE_EXPR_TEST(e, t)  BOOST_TEST( ((e), (t)) )
+#define PRIVATE_EXPR_TEST(e, t)  BOOST_CHECK( ((e), (t)) )
 
 int
 test_main( int , char * [] )
@@ -606,22 +606,22 @@ test_main( int , char * [] )
     MyInt i2(2);
     MyInt i;
 
-    BOOST_TEST( i1.value() == 1 );
-    BOOST_TEST( i2.value() == 2 );
-    BOOST_TEST( i.value() == 0 );
+    BOOST_CHECK( i1.value() == 1 );
+    BOOST_CHECK( i2.value() == 2 );
+    BOOST_CHECK( i.value() == 0 );
 
     cout << "Created MyInt objects.\n";
 
     PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );
 
-    BOOST_TEST( i2 == i );
-    BOOST_TEST( i1 != i2 );
-    BOOST_TEST( i1 <  i2 );
-    BOOST_TEST( i1 <= i2 );
-    BOOST_TEST( i <= i2 );
-    BOOST_TEST( i2 >  i1 );
-    BOOST_TEST( i2 >= i1 );
-    BOOST_TEST( i2 >= i );
+    BOOST_CHECK( i2 == i );
+    BOOST_CHECK( i1 != i2 );
+    BOOST_CHECK( i1 <  i2 );
+    BOOST_CHECK( i1 <= i2 );
+    BOOST_CHECK( i <= i2 );
+    BOOST_CHECK( i2 >  i1 );
+    BOOST_CHECK( i2 >= i1 );
+    BOOST_CHECK( i2 >= i );
 
     PRIVATE_EXPR_TEST( (i = i1 + i2), (i.value() == 3) );
     PRIVATE_EXPR_TEST( (i = i + i2), (i.value() == 5) );
@@ -645,86 +645,86 @@ test_main( int , char * [] )
     MyLong j2(2);
     MyLong j;
 
-    BOOST_TEST( j1.value() == 1 );
-    BOOST_TEST( j2.value() == 2 );
-    BOOST_TEST( j.value() == 0 );
+    BOOST_CHECK( j1.value() == 1 );
+    BOOST_CHECK( j2.value() == 2 );
+    BOOST_CHECK( j.value() == 0 );
 
     cout << "Created MyLong objects.\n";
 
     PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
     
-    BOOST_TEST( j2 == j );
-    BOOST_TEST( 2 == j );
-    BOOST_TEST( j2 == 2 );    
-    BOOST_TEST( j == j2 );
-    BOOST_TEST( j1 != j2 );
-    BOOST_TEST( j1 != 2 );
-    BOOST_TEST( 1 != j2 );
-    BOOST_TEST( j1 <  j2 );
-    BOOST_TEST( 1 <  j2 );
-    BOOST_TEST( j1 <  2 );
-    BOOST_TEST( j1 <= j2 );
-    BOOST_TEST( 1 <= j2 );
-    BOOST_TEST( j1 <= j );
-    BOOST_TEST( j <= j2 );
-    BOOST_TEST( 2 <= j2 );
-    BOOST_TEST( j <= 2 );
-    BOOST_TEST( j2 >  j1 );
-    BOOST_TEST( 2 >  j1 );
-    BOOST_TEST( j2 >  1 );
-    BOOST_TEST( j2 >= j1 );
-    BOOST_TEST( 2 >= j1 );
-    BOOST_TEST( j2 >= 1 );
-    BOOST_TEST( j2 >= j );
-    BOOST_TEST( 2 >= j );
-    BOOST_TEST( j2 >= 2 );
+    BOOST_CHECK( j2 == j );
+    BOOST_CHECK( 2 == j );
+    BOOST_CHECK( j2 == 2 );    
+    BOOST_CHECK( j == j2 );
+    BOOST_CHECK( j1 != j2 );
+    BOOST_CHECK( j1 != 2 );
+    BOOST_CHECK( 1 != j2 );
+    BOOST_CHECK( j1 <  j2 );
+    BOOST_CHECK( 1 <  j2 );
+    BOOST_CHECK( j1 <  2 );
+    BOOST_CHECK( j1 <= j2 );
+    BOOST_CHECK( 1 <= j2 );
+    BOOST_CHECK( j1 <= j );
+    BOOST_CHECK( j <= j2 );
+    BOOST_CHECK( 2 <= j2 );
+    BOOST_CHECK( j <= 2 );
+    BOOST_CHECK( j2 >  j1 );
+    BOOST_CHECK( 2 >  j1 );
+    BOOST_CHECK( j2 >  1 );
+    BOOST_CHECK( j2 >= j1 );
+    BOOST_CHECK( 2 >= j1 );
+    BOOST_CHECK( j2 >= 1 );
+    BOOST_CHECK( j2 >= j );
+    BOOST_CHECK( 2 >= j );
+    BOOST_CHECK( j2 >= 2 );
 
-    BOOST_TEST( (j1 + 2) == 3 );
-    BOOST_TEST( (1 + j2) == 3 );
+    BOOST_CHECK( (j1 + 2) == 3 );
+    BOOST_CHECK( (1 + j2) == 3 );
     PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
     
-    BOOST_TEST( (j + 2) == 5 );
-    BOOST_TEST( (3 + j2) == 5 );
+    BOOST_CHECK( (j + 2) == 5 );
+    BOOST_CHECK( (3 + j2) == 5 );
     PRIVATE_EXPR_TEST( (j = j + j2), (j.value() == 5) );
     
-    BOOST_TEST( (j - 1) == 4 );
+    BOOST_CHECK( (j - 1) == 4 );
     PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
     
-    BOOST_TEST( (j * 2) == 8 );
-    BOOST_TEST( (4 * j2) == 8 );
+    BOOST_CHECK( (j * 2) == 8 );
+    BOOST_CHECK( (4 * j2) == 8 );
     PRIVATE_EXPR_TEST( (j = j * j2), (j.value() == 8) );
     
-    BOOST_TEST( (j / 2) == 4 );
+    BOOST_CHECK( (j / 2) == 4 );
     PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
     
-    BOOST_TEST( (j % 3) == 1 );
+    BOOST_CHECK( (j % 3) == 1 );
     PRIVATE_EXPR_TEST( (j = j % ( j - j1 )), (j.value() == 1) );
     
     PRIVATE_EXPR_TEST( (j = j2 + j2), (j.value() == 4) );
     
-    BOOST_TEST( (1 | j2 | j) == 7 );
-    BOOST_TEST( (j1 | 2 | j) == 7 );
-    BOOST_TEST( (j1 | j2 | 4) == 7 );
+    BOOST_CHECK( (1 | j2 | j) == 7 );
+    BOOST_CHECK( (j1 | 2 | j) == 7 );
+    BOOST_CHECK( (j1 | j2 | 4) == 7 );
     PRIVATE_EXPR_TEST( (j = j1 | j2 | j), (j.value() == 7) );
     
-    BOOST_TEST( (7 & j2) == 2 );
-    BOOST_TEST( (j & 2) == 2 );
+    BOOST_CHECK( (7 & j2) == 2 );
+    BOOST_CHECK( (j & 2) == 2 );
     PRIVATE_EXPR_TEST( (j = j & j2), (j.value() == 2) );
     
     PRIVATE_EXPR_TEST( (j = j | j1), (j.value() == 3) );
     
-    BOOST_TEST( (3 ^ j1) == 2 );
-    BOOST_TEST( (j ^ 1) == 2 );
+    BOOST_CHECK( (3 ^ j1) == 2 );
+    BOOST_CHECK( (j ^ 1) == 2 );
     PRIVATE_EXPR_TEST( (j = j ^ j1), (j.value() == 2) );
     
     PRIVATE_EXPR_TEST( (j = ( j + j1 ) * ( j2 | j1 )), (j.value() == 9) );
 
-    BOOST_TEST( (j1 << 2) == 4 );
-    BOOST_TEST( (j2 << 1) == 4 );
+    BOOST_CHECK( (j1 << 2) == 4 );
+    BOOST_CHECK( (j2 << 1) == 4 );
     PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );
 
-    BOOST_TEST( (j >> 2) == 1 );
-    BOOST_TEST( (j2 >> 1) == 1 );
+    BOOST_CHECK( (j >> 2) == 1 );
+    BOOST_CHECK( (j2 >> 1) == 1 );
     PRIVATE_EXPR_TEST( (j = j2 >> j1), (j.value() == 1) );
     
     cout << "Performed tests on MyLong objects.\n";
@@ -733,22 +733,22 @@ test_main( int , char * [] )
     MyChar k2(2);
     MyChar k;
 
-    BOOST_TEST( k1.value() == 1 );
-    BOOST_TEST( k2.value() == 2 );
-    BOOST_TEST( k.value() == 0 );
+    BOOST_CHECK( k1.value() == 1 );
+    BOOST_CHECK( k2.value() == 2 );
+    BOOST_CHECK( k.value() == 0 );
 
     cout << "Created MyChar objects.\n";
 
     PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );
 
-    BOOST_TEST( k2 == k );
-    BOOST_TEST( k1 != k2 );
-    BOOST_TEST( k1 <  k2 );
-    BOOST_TEST( k1 <= k2 );
-    BOOST_TEST( k <= k2 );
-    BOOST_TEST( k2 >  k1 );
-    BOOST_TEST( k2 >= k1 );
-    BOOST_TEST( k2 >= k );
+    BOOST_CHECK( k2 == k );
+    BOOST_CHECK( k1 != k2 );
+    BOOST_CHECK( k1 <  k2 );
+    BOOST_CHECK( k1 <= k2 );
+    BOOST_CHECK( k <= k2 );
+    BOOST_CHECK( k2 >  k1 );
+    BOOST_CHECK( k2 >= k1 );
+    BOOST_CHECK( k2 >= k );
     
     cout << "Performed tests on MyChar objects.\n";
 
@@ -756,39 +756,39 @@ test_main( int , char * [] )
     MyShort l2(2);
     MyShort l;
 
-    BOOST_TEST( l1.value() == 1 );
-    BOOST_TEST( l2.value() == 2 );
-    BOOST_TEST( l.value() == 0 );
+    BOOST_CHECK( l1.value() == 1 );
+    BOOST_CHECK( l2.value() == 2 );
+    BOOST_CHECK( l.value() == 0 );
 
     cout << "Created MyShort objects.\n";
 
     PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
     
-    BOOST_TEST( l2 == l );
-    BOOST_TEST( 2 == l );
-    BOOST_TEST( l2 == 2 );    
-    BOOST_TEST( l == l2 );
-    BOOST_TEST( l1 != l2 );
-    BOOST_TEST( l1 != 2 );
-    BOOST_TEST( 1 != l2 );
-    BOOST_TEST( l1 <  l2 );
-    BOOST_TEST( 1 <  l2 );
-    BOOST_TEST( l1 <  2 );
-    BOOST_TEST( l1 <= l2 );
-    BOOST_TEST( 1 <= l2 );
-    BOOST_TEST( l1 <= l );
-    BOOST_TEST( l <= l2 );
-    BOOST_TEST( 2 <= l2 );
-    BOOST_TEST( l <= 2 );
-    BOOST_TEST( l2 >  l1 );
-    BOOST_TEST( 2 >  l1 );
-    BOOST_TEST( l2 >  1 );
-    BOOST_TEST( l2 >= l1 );
-    BOOST_TEST( 2 >= l1 );
-    BOOST_TEST( l2 >= 1 );
-    BOOST_TEST( l2 >= l );
-    BOOST_TEST( 2 >= l );
-    BOOST_TEST( l2 >= 2 );
+    BOOST_CHECK( l2 == l );
+    BOOST_CHECK( 2 == l );
+    BOOST_CHECK( l2 == 2 );    
+    BOOST_CHECK( l == l2 );
+    BOOST_CHECK( l1 != l2 );
+    BOOST_CHECK( l1 != 2 );
+    BOOST_CHECK( 1 != l2 );
+    BOOST_CHECK( l1 <  l2 );
+    BOOST_CHECK( 1 <  l2 );
+    BOOST_CHECK( l1 <  2 );
+    BOOST_CHECK( l1 <= l2 );
+    BOOST_CHECK( 1 <= l2 );
+    BOOST_CHECK( l1 <= l );
+    BOOST_CHECK( l <= l2 );
+    BOOST_CHECK( 2 <= l2 );
+    BOOST_CHECK( l <= 2 );
+    BOOST_CHECK( l2 >  l1 );
+    BOOST_CHECK( 2 >  l1 );
+    BOOST_CHECK( l2 >  1 );
+    BOOST_CHECK( l2 >= l1 );
+    BOOST_CHECK( 2 >= l1 );
+    BOOST_CHECK( l2 >= 1 );
+    BOOST_CHECK( l2 >= l );
+    BOOST_CHECK( 2 >= l );
+    BOOST_CHECK( l2 >= 2 );
     
     cout << "Performed tests on MyShort objects.\n";
     
@@ -798,44 +798,44 @@ test_main( int , char * [] )
     MyDoubleInt di;
     MyDoubleInt tmp;
 
-    BOOST_TEST( di1.value() == 1 );
-    BOOST_TEST( di2.value() == 2 );
-    BOOST_TEST( di2.value() == 2 );
-    BOOST_TEST( di.value() == 0 );
+    BOOST_CHECK( di1.value() == 1 );
+    BOOST_CHECK( di2.value() == 2 );
+    BOOST_CHECK( di2.value() == 2 );
+    BOOST_CHECK( di.value() == 0 );
 
     cout << "Created MyDoubleInt objects.\n";
 
     PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
     
-    BOOST_TEST( di2 == di );
-    BOOST_TEST( 2 == di );
-    BOOST_TEST( di == 2 );
-    BOOST_TEST( di1 < di2 );
-    BOOST_TEST( 1 < di2 );
-    BOOST_TEST( di1 <= di2 );
-    BOOST_TEST( 1 <= di2 );
-    BOOST_TEST( di2 > di1 );
-    BOOST_TEST( di2 > 1 );
-    BOOST_TEST( di2 >= di1 );
-    BOOST_TEST( di2 >= 1 );
-    BOOST_TEST( di1 / di2 == half );
-    BOOST_TEST( di1 / 2 == half );
-    BOOST_TEST( 1 / di2 == half );
+    BOOST_CHECK( di2 == di );
+    BOOST_CHECK( 2 == di );
+    BOOST_CHECK( di == 2 );
+    BOOST_CHECK( di1 < di2 );
+    BOOST_CHECK( 1 < di2 );
+    BOOST_CHECK( di1 <= di2 );
+    BOOST_CHECK( 1 <= di2 );
+    BOOST_CHECK( di2 > di1 );
+    BOOST_CHECK( di2 > 1 );
+    BOOST_CHECK( di2 >= di1 );
+    BOOST_CHECK( di2 >= 1 );
+    BOOST_CHECK( di1 / di2 == half );
+    BOOST_CHECK( di1 / 2 == half );
+    BOOST_CHECK( 1 / di2 == half );
     PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=2) == half) );
     PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=di2) == half) );
-    BOOST_TEST( di1 * di2 == di2 );
-    BOOST_TEST( di1 * 2 == di2 );
-    BOOST_TEST( 1 * di2 == di2 );
+    BOOST_CHECK( di1 * di2 == di2 );
+    BOOST_CHECK( di1 * 2 == di2 );
+    BOOST_CHECK( 1 * di2 == di2 );
     PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=2) == di2) );
     PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=di2) == di2) );
-    BOOST_TEST( di2 - di1 == di1 );
-    BOOST_TEST( di2 - 1 == di1 );
-    BOOST_TEST( 2 - di1 == di1 );
+    BOOST_CHECK( di2 - di1 == di1 );
+    BOOST_CHECK( di2 - 1 == di1 );
+    BOOST_CHECK( 2 - di1 == di1 );
     PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=1) == di1) );
     PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=di1) == di1) );
-    BOOST_TEST( di1 + di1 == di2 );
-    BOOST_TEST( di1 + 1 == di2 );
-    BOOST_TEST( 1 + di1 == di2 );
+    BOOST_CHECK( di1 + di1 == di2 );
+    BOOST_CHECK( di1 + 1 == di2 );
+    BOOST_CHECK( 1 + di1 == di2 );
     PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=1) == di2) );
     PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=di1) == di2) );
 
@@ -846,48 +846,48 @@ test_main( int , char * [] )
     MyLongInt li;
     MyLongInt tmp2;
 
-    BOOST_TEST( li1.value() == 1 );
-    BOOST_TEST( li2.value() == 2 );
-    BOOST_TEST( li.value() == 0 );
+    BOOST_CHECK( li1.value() == 1 );
+    BOOST_CHECK( li2.value() == 2 );
+    BOOST_CHECK( li.value() == 0 );
 
     cout << "Created MyLongInt objects.\n";
 
     PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
     
-    BOOST_TEST( li2 == li );
-    BOOST_TEST( 2 == li );
-    BOOST_TEST( li == 2 );
-    BOOST_TEST( li1 < li2 );
-    BOOST_TEST( 1 < li2 );
-    BOOST_TEST( li1 <= li2 );
-    BOOST_TEST( 1 <= li2 );
-    BOOST_TEST( li2 > li1 );
-    BOOST_TEST( li2 > 1 );
-    BOOST_TEST( li2 >= li1 );
-    BOOST_TEST( li2 >= 1 );
-    BOOST_TEST( li1 % li2 == li1 );
-    BOOST_TEST( li1 % 2 == li1 );
-    BOOST_TEST( 1 % li2 == li1 );
+    BOOST_CHECK( li2 == li );
+    BOOST_CHECK( 2 == li );
+    BOOST_CHECK( li == 2 );
+    BOOST_CHECK( li1 < li2 );
+    BOOST_CHECK( 1 < li2 );
+    BOOST_CHECK( li1 <= li2 );
+    BOOST_CHECK( 1 <= li2 );
+    BOOST_CHECK( li2 > li1 );
+    BOOST_CHECK( li2 > 1 );
+    BOOST_CHECK( li2 >= li1 );
+    BOOST_CHECK( li2 >= 1 );
+    BOOST_CHECK( li1 % li2 == li1 );
+    BOOST_CHECK( li1 % 2 == li1 );
+    BOOST_CHECK( 1 % li2 == li1 );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=2) == li1) );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=li2) == li1) );
-    BOOST_TEST( li1 / li2 == 0 );
-    BOOST_TEST( li1 / 2 == 0 );
-    BOOST_TEST( 1 / li2 == 0 );
+    BOOST_CHECK( li1 / li2 == 0 );
+    BOOST_CHECK( li1 / 2 == 0 );
+    BOOST_CHECK( 1 / li2 == 0 );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=2) == 0) );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=li2) == 0) );
-    BOOST_TEST( li1 * li2 == li2 );
-    BOOST_TEST( li1 * 2 == li2 );
-    BOOST_TEST( 1 * li2 == li2 );
+    BOOST_CHECK( li1 * li2 == li2 );
+    BOOST_CHECK( li1 * 2 == li2 );
+    BOOST_CHECK( 1 * li2 == li2 );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=2) == li2) );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=li2) == li2) );
-    BOOST_TEST( li2 - li1 == li1 );
-    BOOST_TEST( li2 - 1 == li1 );
-    BOOST_TEST( 2 - li1 == li1 );
+    BOOST_CHECK( li2 - li1 == li1 );
+    BOOST_CHECK( li2 - 1 == li1 );
+    BOOST_CHECK( 2 - li1 == li1 );
     PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=1) == li1) );
     PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=li1) == li1) );
-    BOOST_TEST( li1 + li1 == li2 );
-    BOOST_TEST( li1 + 1 == li2 );
-    BOOST_TEST( 1 + li1 == li2 );
+    BOOST_CHECK( li1 + li1 == li2 );
+    BOOST_CHECK( li1 + 1 == li2 );
+    BOOST_CHECK( 1 + li1 == li2 );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=1) == li2) );
     PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=li1) == li2) );
 

ref_test.cpp

@@ -60,11 +60,11 @@ struct ref_wrapper
 
     static void test(T x)
     {
-        BOOST_TEST(passthru(ref(x)) == &x);
-        BOOST_TEST(&ref(x).get() == &x);
+        BOOST_CHECK(passthru(ref(x)) == &x);
+        BOOST_CHECK(&ref(x).get() == &x);
 
-        BOOST_TEST(cref_passthru(cref(x)) == &x);
-        BOOST_TEST(&cref(x).get() == &x);
+        BOOST_CHECK(cref_passthru(cref(x)) == &x);
+        BOOST_CHECK(&cref(x).get() == &x);
     }
 };
 

sublibs

@@ -0,0 +1 @@
+The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.

test/Jamfile

@@ -19,7 +19,7 @@ local test_monitor = <lib>@boost/libs/test/build/boost_test_exec_monitor ;
 # Please keep the tests ordered by filename
 test-suite utility
     :
-        [ run ../addressof_test.cpp $(test_monitor) ]
+        [ run ../addressof_test.cpp ]
         [ run ../assert_test.cpp ]
         [ run ../base_from_member_test.cpp ]
         [ run ../binary_search_test.cpp ]

test/Jamfile.v2

@@ -12,7 +12,7 @@ import testing ;
 # Please keep the tests ordered by filename
 test-suite utility
     :
-        [ run ../addressof_test.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../addressof_test.cpp ]
         [ run ../assert_test.cpp ]
         [ run ../base_from_member_test.cpp ]
         [ run ../binary_search_test.cpp ]

utility.htm

@@ -175,7 +175,8 @@ void f() {
                 <code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
                 value for <em>N</em>.</p>
 
-                <p>This implementation of <code>result_of</code> requires class template partial specialization, the ability to parse function types properly, and support for SFINAE. Contributed by Doug Gregor.</p>
+                <a name="BOOST_NO_RESULT_OF"></a>
+                <p>This implementation of <code>result_of</code> requires class template partial specialization, the ability to parse function types properly, and support for SFINAE. If <code>result_of</code> is not supported by your compiler, including the header <code>boost/utility/result_of.hpp</code> will define the macro <code>BOOST_NO_RESULT_OF</code>. Contributed by Doug Gregor.</p>
 
 		<h2>Class templates for the Base-from-Member Idiom</h2>
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>

value_init.htm

@@ -15,8 +15,8 @@
 <h2>Contents</h2>
                    
 <dl>
-  <dt><a href="#intro">Rationale</a></dt>
-  <dt><a href="#rationale">Introduction</a></dt>
+  <dt><a href="#rationale">Rationale</a></dt>
+  <dt><a href="#intro">Introduction</a></dt>
 </dl>
                    
 <ul>
@@ -49,7 +49,7 @@ a solution   with consistent syntax for value   initialization of scalar,
 union and class   types. <br>
   </p>
         
-<h2><a name="into"></a>Introduction</h2>
+<h2><a name="intro"></a>Introduction</h2>
      
 <p>The C++ standard [<a href="#references">1</a>] contains the definitions 
     of <code>zero-initialization</code> and <code>default-initialization</code>.
@@ -131,7 +131,7 @@ data member:</p>
                    
 <h2><a name="val_init"><code>template class value_initialized&lt;T&gt;</code></a></h2>
                    
-<pre>namespace boost {<br><br>template&lt;class T&gt;<br>class value_initialized<br>{<br>  public :<br>    value_initialized() : x() {}<br>    operator T&amp;() const { return x ; }<br>    T&amp; data() const { return x ; }<br><br>  private :<br>    <i>impll-defined</i> x ;<br>} ;<br><br>template&lt;class T&gt;<br>T const&amp; get ( value_initialized&lt;T&gt; const&amp; x )<br>{<br>  return x.data() ;<br>}<br><br>template&lt;class T&gt;<br>T&amp; get ( value_initialized&lt;T&gt;&amp; x )<br>{<br>  return x.data() ;<br>}<br><br>} // namespace boost<br></pre>
+<pre>namespace boost {<br><br>template&lt;class T&gt;<br>class value_initialized<br>{<br>  public :<br>    value_initialized() : x() {}<br>    operator T&amp;() const { return x ; }<br>    T&amp; data() const { return x ; }<br><br>  private :<br>    <i>unspecified</i> x ;<br>} ;<br><br>template&lt;class T&gt;<br>T const&amp; get ( value_initialized&lt;T&gt; const&amp; x )<br>{<br>  return x.data() ;<br>}<br><br>template&lt;class T&gt;<br>T&amp; get ( value_initialized&lt;T&gt;&amp; x )<br>{<br>  return x.data() ;<br>}<br><br>} // namespace boost<br></pre>
                     
 <p>An object of this template class is a <code>T</code>-wrapper convertible 
     to <code>'T&amp;'</code> whose wrapped object (data member of type <code>T</code>) 

value_init_test.cpp

@@ -64,27 +64,27 @@ template<class T>
 void test ( T const& y, T const& z )
 {
   boost::value_initialized<T> x ;
-  BOOST_TEST ( y == x ) ;
-  BOOST_TEST ( y == boost::get(x) ) ;
+  BOOST_CHECK ( y == x ) ;
+  BOOST_CHECK ( y == boost::get(x) ) ;
   static_cast<T&>(x) = z ;
   boost::get(x) = z ;
-  BOOST_TEST ( x == z ) ;
+  BOOST_CHECK ( x == z ) ;
 
   boost::value_initialized<T> const x_c ;
-  BOOST_TEST ( y == x_c ) ;
-  BOOST_TEST ( y == boost::get(x_c) ) ;
+  BOOST_CHECK ( y == x_c ) ;
+  BOOST_CHECK ( y == boost::get(x_c) ) ;
   T& x_c_ref = x_c ;
   x_c_ref = z ;
-  BOOST_TEST ( x_c == z ) ;
+  BOOST_CHECK ( x_c == z ) ;
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
   boost::value_initialized<T const> cx ;
-  BOOST_TEST ( y == cx ) ;
-  BOOST_TEST ( y == boost::get(cx) ) ;
+  BOOST_CHECK ( y == cx ) ;
+  BOOST_CHECK ( y == boost::get(cx) ) ;
 
   boost::value_initialized<T const> const cx_c ;
-  BOOST_TEST ( y == cx_c ) ;
-  BOOST_TEST ( y == boost::get(cx_c) ) ;
+  BOOST_CHECK ( y == cx_c ) ;
+  BOOST_CHECK ( y == boost::get(cx_c) ) ;
 #endif
 }