Type_traits: Added add_const/add_volatile/is_fucntion tests.

Updated docs for new templates. Updated test programs to test abstract base classes. [SVN r9638]
2001-03-25 10:31:16 +00:00
parent 546727c5f3
commit 23e280ffe4
12 changed files with 410 additions and 8 deletions
--- a/examples/iter_swap_example.cpp
+++ b/examples/iter_swap_example.cpp
@ -103,8 +103,7 @@ int main()
   opt::iter_swap(v1.begin(), v1.begin()+1);
   opt::iter_swap(v2.begin(), v2.begin()+1);

-   cout << "Press any key to exit...";
-   cin.get();
+   return 0;
 }


--- a/index.htm
+++ b/index.htm
@ -196,6 +196,20 @@ template instead.</p>
        that is_enum is currently broken under Borland C++).</td>
        <td valign="top" width="5%">&nbsp;</td>
    </tr>
+    <tr>
+        <td>&nbsp;</td>
+        <td valign="top" bgcolor="#C0C0C0"><code>::boost::is_function&lt;T&gt;::value</code></td>
+        <td valign="top" bgcolor="#C0C0C0">Evaluates to true only
+        if T is a function type (note not a reference or pointer
+        to function).</td>
+        <td valign="top" bgcolor="#C0C0C0"><p align="center">3.9.2p1</p>
+        <p align="center">8.3.5</p>
+        </td>
+        <td valign="top" bgcolor="#C0C0C0">Without partial
+        specialisation support, this template does not compile
+        for reference types.</td>
+        <td>&nbsp;</td>
+    </tr>
 </table>

 <p>&nbsp;</p>
@ -604,6 +618,24 @@ transformation to the template argument T:</p>
        </td>
        <td valign="top" width="5%">&nbsp;</td>
    </tr>
+    <tr>
+        <td>&nbsp;</td>
+        <td valign="top" bgcolor="#C0C0C0"><code>::boost::add_const&lt;T&gt;::type</code></td>
+        <td valign="top" bgcolor="#C0C0C0">The same as &quot;T
+        const&quot; for all T.</td>
+        <td valign="top" bgcolor="#C0C0C0">3.9.3</td>
+        <td valign="top" bgcolor="#C0C0C0">&nbsp;</td>
+        <td>&nbsp;</td>
+    </tr>
+    <tr>
+        <td>&nbsp;</td>
+        <td valign="top" bgcolor="#C0C0C0"><code>::boost::add_volatile&lt;T&gt;::type</code></td>
+        <td valign="top" bgcolor="#C0C0C0">The same as &quot;T
+        volatile&quot; for all T.</td>
+        <td valign="top" bgcolor="#C0C0C0">3.9.3</td>
+        <td valign="top" bgcolor="#C0C0C0">&nbsp;</td>
+        <td>&nbsp;</td>
+    </tr>
 </table>

 <p>As the table above indicates, support for partial
@ -744,6 +776,12 @@ template.</p>
        <td valign="top" width="41%" bgcolor="#008080">Header</td>
        <td valign="top" width="9%">&nbsp;</td>
    </tr>
+    <tr>
+        <td>&nbsp;</td>
+        <td valign="top" bgcolor="#C0C0C0"><code>add_const</code></td>
+        <td valign="top" bgcolor="#C0C0C0"><code>&lt;boost/type_traits/transform_traits.hpp&gt;</code></td>
+        <td>&nbsp;</td>
+    </tr>
    <tr>
        <td valign="top" width="7%">&nbsp;</td>
        <td valign="top" width="43%" bgcolor="#C0C0C0"><code>add_pointer</code></td>
@ -756,6 +794,12 @@ template.</p>
        <td valign="top" width="41%" bgcolor="#C0C0C0"><code>&lt;boost/type_traits/transform_traits.hpp&gt;</code></td>
        <td valign="top" width="9%">&nbsp;</td>
    </tr>
+    <tr>
+        <td>&nbsp;</td>
+        <td valign="top" bgcolor="#C0C0C0"><code>add_volatile</code></td>
+        <td valign="top" bgcolor="#C0C0C0"><code>&lt;boost/type_traits/transform_traits.hpp&gt;</code></td>
+        <td>&nbsp;</td>
+    </tr>
    <tr>
        <td valign="top" width="7%">&nbsp;</td>
        <td valign="top" width="43%" bgcolor="#C0C0C0"><code>alignment_of</code></td>
@ -841,6 +885,12 @@ template.</p>
        <td valign="top" width="41%" bgcolor="#C0C0C0"><code>&lt;boost/type_traits/arithmetic_traits.hpp&gt;</code></td>
        <td valign="top" width="9%">&nbsp;</td>
    </tr>
+    <tr>
+        <td>&nbsp;</td>
+        <td valign="top" bgcolor="#C0C0C0"><code>is_function</code></td>
+        <td valign="top" bgcolor="#C0C0C0"><code>&lt;boost/type_traits/function_traits.hpp&gt;</code></td>
+        <td>&nbsp;</td>
+    </tr>
    <tr>
        <td valign="top" width="7%">&nbsp;</td>
        <td valign="top" width="43%" bgcolor="#C0C0C0"><code>is_fundamental</code></td>
--- a/tests/alignment_test.cpp
+++ b/tests/alignment_test.cpp
@ -34,7 +34,7 @@ int main(int argc, char* argv[])
   align_test(VB);
   align_test(VD);
   value_test(0, ::boost::alignment_of<void>::value);
-   
+
   return check_result(argc, argv);
 }

--- a/tests/arithmetic_traits_test.cpp
+++ b/tests/arithmetic_traits_test.cpp
@ -36,6 +36,7 @@ int main(int argc, char* argv[])
   value_test(true, boost::is_void<volatile void>::value)
   value_test(true, boost::is_void<const volatile void>::value)
   value_test(false, boost::is_void<int>::value)
+   value_test(false, boost::is_void<test_abc1>::value)

   value_test(false, boost::is_integral<UDT>::value)
   value_test(false, boost::is_integral<void>::value)
@ -121,6 +122,7 @@ int main(int argc, char* argv[])
   value_test(true, boost::is_integral<const volatile __int64>::value)
   value_test(true, boost::is_integral<const volatile unsigned __int64>::value)
   #endif
+   value_test(false, boost::is_integral<test_abc1>::value)
   value_test(true, boost::is_float<const volatile float>::value)
   value_test(true, boost::is_float<const volatile double>::value)
   value_test(true, boost::is_float<const volatile long double>::value)
@ -136,6 +138,7 @@ int main(int argc, char* argv[])
   value_test(false, boost::is_float<int>::value)
   value_test(false, boost::is_float<void>::value)
   value_test(false, boost::is_float<UDT>::value)
+   value_test(false, boost::is_float<test_abc1>::value)


   value_test(false, boost::is_arithmetic<UDT>::value)
@ -162,8 +165,10 @@ int main(int argc, char* argv[])
   value_test(true, boost::is_arithmetic<__int64>::value)
   value_test(true, boost::is_arithmetic<unsigned __int64>::value)
   #endif
+   value_test(false, boost::is_arithmetic<test_abc1>::value)

   value_test(false, boost::is_fundamental<UDT>::value)
+   value_test(false, boost::is_fundamental<test_abc1>::value)
   value_test(true, boost::is_fundamental<void>::value)
   value_test(true, boost::is_fundamental<bool>::value)
   value_test(true, boost::is_fundamental<char>::value)
--- a/tests/composite_traits_test.cpp
+++ b/tests/composite_traits_test.cpp
@ -44,6 +44,9 @@ int main(int argc, char* argv[])
   value_test(false, boost::is_array<int(&)[2]>::value)
   value_test(false, boost::is_array<f1>::value)
   value_test(false, boost::is_array<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::is_array<test_abc1>::value)
+#endif

   value_test(false, boost::is_pointer<int>::value)
   value_test(false, boost::is_pointer<int&>::value)
@ -71,6 +74,9 @@ int main(int argc, char* argv[])
   value_test(false, boost::is_pointer<mf2>::value)
   value_test(false, boost::is_pointer<mf3>::value)
   value_test(false, boost::is_pointer<mf4>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::is_pointer<test_abc1>::value)
+#endif

   value_test(false, boost::is_reference<bool>::value)
   value_test(true, boost::is_reference<int&>::value)
@ -81,6 +87,9 @@ int main(int argc, char* argv[])
   value_test(true, boost::is_reference<cr_type>::value)
   value_test(true, boost::is_reference<const UDT&>::value)
   value_test(false, boost::is_reference<void>::value)
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC)
+   value_test(false, boost::is_reference<test_abc1>::value)
+#endif

   value_test(false, boost::is_member_pointer<f1>::value)
   value_test(false, boost::is_member_pointer<f2>::value)
@ -91,12 +100,18 @@ int main(int argc, char* argv[])
   value_test(true, boost::is_member_pointer<mf3>::value)
   value_test(true, boost::is_member_pointer<mf4>::value)
   value_test(false, boost::is_member_pointer<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::is_member_pointer<test_abc1>::value)
+#endif

   value_test(false, boost::is_enum<int>::value)
   value_test(true, boost::is_enum<enum_UDT>::value)
   value_test(false, boost::is_enum<int_convertible>::value)
-   value_test(false, boost::is_enum<int&>::value)
+   //value_test(false, boost::is_enum<int&>::value)
   value_test(false, boost::is_enum<void>::value)
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC)
+   value_test(false, boost::is_enum<test_abc1>::value)
+#endif

   return check_result(argc, argv);
 }
--- a/tests/cv_traits_test.cpp
+++ b/tests/cv_traits_test.cpp
@ -26,12 +26,28 @@ int main(int argc, char* argv[])

   value_test(false, boost::is_const<void>::value)
   value_test(true, boost::is_const<const void>::value)
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC)
+   value_test(false, boost::is_const<test_abc1>::value)
+   value_test(true, boost::is_const<const test_abc1>::value)
+#endif
   value_test(false, boost::is_const<int>::value)
   value_test(true, boost::is_const<const int>::value)
   value_test(true, boost::is_const<const UDT>::value)
   value_test(true, boost::is_const<const volatile UDT>::value)
+   value_test(false, boost::is_const<const int&>::value)
+#ifndef __GNUC__
+   value_test(false, boost::is_const<cr_type>::value)
+#else
+   value_fail(false, boost::is_const<cr_type>::value)
+#endif
+
+
   value_test(false, boost::is_volatile<void>::value)
   value_test(true, boost::is_volatile<volatile void>::value)
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC)
+   value_test(false, boost::is_volatile<test_abc1>::value)
+   value_test(true, boost::is_volatile<volatile test_abc1>::value)
+#endif
   value_test(false, boost::is_volatile<int>::value)
   value_test(true, boost::is_volatile<volatile int>::value)
   value_test(true, boost::is_volatile<volatile UDT>::value)
@ -43,7 +59,7 @@ int main(int argc, char* argv[])
 //
 // define the number of failures expected for given compilers:
 #ifdef BOOST_MSVC
-unsigned int expected_failures = 2;
+unsigned int expected_failures = 3;
 #else
 unsigned int expected_failures = 0;
 #endif
--- a/tests/is_convertible_test.cpp
+++ b/tests/is_convertible_test.cpp
@ -52,6 +52,7 @@ int main(int argc, char* argv[])
   value_test(true, (boost::is_convertible<non_int_pointer, int*>::value));
   value_test(true, (boost::is_convertible<non_int_pointer, void*>::value));
   value_test(true, (boost::is_convertible<int, int_constructible>::value));
+   value_test(false, (boost::is_convertible<test_abc1&, test_abc2&>::value));

   return check_result(argc, argv);
 }
--- a/tests/is_function_test.cpp
+++ b/tests/is_function_test.cpp
@ -0,0 +1,72 @@
+
+//  (C) Copyright 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.
+
+#include <boost/type_traits.hpp>
+#include "boost/type_traits/type_traits_test.hpp"
+
+template <class T>
+void is_function_test(const T& foo)
+{
+   value_test(true, ::boost::is_function<T>::value);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, ::boost::is_void<T>::value);
+   value_test(false, ::boost::is_integral<T>::value);
+   value_test(false, ::boost::is_float<T>::value);
+   value_test(false, ::boost::is_arithmetic<T>::value);
+   value_test(false, ::boost::is_fundamental<T>::value);
+   value_test(false, ::boost::is_pointer<T>::value);
+   value_test(false, ::boost::is_reference<T>::value);
+   value_test(false, ::boost::is_member_pointer<T>::value);
+   value_test(false, ::boost::is_enum<T>::value);
+   value_test(false, ::boost::is_union<T>::value);
+   value_test(false, ::boost::is_object<T>::value);
+   value_test(false, ::boost::is_scalar<T>::value);
+   value_test(false, ::boost::is_class<T>::value);
+   value_test(false, ::boost::is_compound<T>::value);
+   value_test(false, ::boost::is_POD<T>::value);
+   value_test(false, ::boost::has_trivial_constructor<T>::value);
+   value_test(false, ::boost::has_trivial_copy<T>::value);
+   value_test(false, ::boost::has_trivial_assign<T>::value);
+   value_test(false, ::boost::has_trivial_destructor<T>::value);
+   value_test(false, ::boost::is_empty<T>::value);
+#endif
+}
+
+void foo0(){};
+void foo1(int){};
+void foo2(int&, double){};
+void foo3(int&, bool, int, int){};
+void foo4(int, bool, int*, int[], int, int, int, int, int){};
+
+
+int main(int argc, char* argv[])
+{
+   is_function_test(foo0);
+   is_function_test(foo1);
+   is_function_test(foo2);
+   is_function_test(foo3);
+   is_function_test(foo4);
+
+   value_test(false, ::boost::is_function<void>::value);
+   value_test(false, ::boost::is_function<int>::value);
+   value_test(false, ::boost::is_function<int*>::value);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, ::boost::is_function<const int&>::value);
+   value_test(false, ::boost::is_function<int (&)(int)>::value);
+#endif
+   value_test(false, ::boost::is_function<int[]>::value);
+   value_test(false, ::boost::is_function<test_abc1>::value);
+   value_test(false, ::boost::is_function<int (*)(int)>::value);
+
+   return check_result(argc, argv);
+}
+
+//
+// define the number of failures expected for given compilers:
+unsigned int expected_failures = 0;
+
+
+
--- a/tests/is_same_test.cpp
+++ b/tests/is_same_test.cpp
@ -27,6 +27,10 @@ int main(int argc, char* argv[])
   value_test(false, (::boost::is_same<void, int>::value))
   value_test(true, (::boost::is_same<void, void>::value))
   value_test(false, (::boost::is_same<void, const void>::value))
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_MSVC)
+   value_test(true, (::boost::is_same<test_abc1, test_abc1>::value))
+   value_test(false, (::boost::is_same<test_abc1, const test_abc1>::value))
+#endif

   return check_result(argc, argv);
 }
--- a/tests/object_type_traits_test.cpp
+++ b/tests/object_type_traits_test.cpp
@ -44,6 +44,10 @@ int main(int argc, char* argv[])
   value_test(false, boost::is_class<enum_UDT>::value)
   value_test(true, boost::is_class<UDT>::value)
   value_test(true, boost::is_class<UDT const>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(true, boost::is_class<test_abc1>::value)
+   value_test(true, boost::is_class<test_abc1 const>::value)
+#endif
   value_test(true, boost::is_class<UDT volatile>::value)
   value_test(true, boost::is_class<empty_UDT>::value)
   value_test(true, boost::is_class<std::iostream>::value)
@ -54,6 +58,9 @@ int main(int argc, char* argv[])

   value_test(true, boost::is_object<int>::value)
   value_test(true, boost::is_object<UDT>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(true, boost::is_object<test_abc1>::value)
+#endif
   value_test(false, boost::is_object<int&>::value)
   value_test(false, boost::is_object<void>::value)

@ -61,12 +68,18 @@ int main(int argc, char* argv[])
   value_test(true, boost::is_scalar<void*>::value)
   value_test(false, boost::is_scalar<void>::value)
   value_test(false, boost::is_scalar<UDT>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::is_scalar<test_abc1>::value)
+#endif
   value_test(false, boost::is_scalar<int&>::value)

   value_test(true, boost::is_compound<UDT>::value)
   value_test(true, boost::is_compound<void*>::value)
   value_test(false, boost::is_compound<void>::value)
   value_test(false, boost::is_compound<int>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(true, boost::is_compound<test_abc1>::value)
+#endif

   value_test(true, boost::is_POD<int>::value)
   value_test(true, boost::is_POD<int*>::value)
@ -84,6 +97,9 @@ int main(int argc, char* argv[])
   value_test(false, boost::is_POD<empty_UDT>::value)
   value_test(true, boost::is_POD<enum_UDT>::value)
   value_test(true, boost::is_POD<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::is_POD<test_abc1>::value)
+#endif

   value_test(true, boost::has_trivial_constructor<int>::value)
   value_test(true, boost::has_trivial_constructor<int*>::value)
@ -99,6 +115,9 @@ int main(int argc, char* argv[])
   value_test(true, boost::has_trivial_constructor<empty_UDT>::value)
   value_test(true, boost::has_trivial_constructor<enum_UDT>::value)
   value_test(true, boost::has_trivial_constructor<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::has_trivial_constructor<test_abc1>::value)
+#endif

   value_test(true, boost::has_trivial_copy<int>::value)
   value_test(true, boost::has_trivial_copy<int*>::value)
@ -115,6 +134,9 @@ int main(int argc, char* argv[])
   value_test(true, boost::has_trivial_copy<empty_UDT>::value)
   value_test(true, boost::has_trivial_copy<enum_UDT>::value)
   value_test(true, boost::has_trivial_copy<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::has_trivial_copy<test_abc1>::value)
+#endif

   value_test(true, boost::has_trivial_assign<int>::value)
   value_test(true, boost::has_trivial_assign<int*>::value)
@ -131,6 +153,9 @@ int main(int argc, char* argv[])
   value_test(true, boost::has_trivial_assign<empty_UDT>::value)
   value_test(true, boost::has_trivial_assign<enum_UDT>::value)
   value_test(true, boost::has_trivial_assign<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::has_trivial_assign<test_abc1>::value)
+#endif

   value_test(true, boost::has_trivial_destructor<int>::value)
   value_test(true, boost::has_trivial_destructor<int*>::value)
@ -146,6 +171,9 @@ int main(int argc, char* argv[])
   value_test(false, boost::has_trivial_destructor<empty_UDT>::value)
   value_test(true, boost::has_trivial_destructor<enum_UDT>::value)
   value_test(true, boost::has_trivial_destructor<void>::value)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   value_test(false, boost::has_trivial_destructor<test_abc1>::value)
+#endif

   soft_value_test(false, boost::is_empty<int>::value)
   soft_value_test(false, boost::is_empty<int*>::value)
--- a/tests/transform_traits_test.cpp
+++ b/tests/transform_traits_test.cpp
@ -290,7 +290,7 @@ BOOST_DECL_TRANSFORM_TEST(add_reference_test_8, ::boost::add_reference, const [2
 BOOST_DECL_TRANSFORM_TEST(add_reference_test_9, ::boost::add_reference, const &, const&)
 BOOST_DECL_TRANSFORM_TEST(add_reference_test_10, ::boost::add_reference, const*, const*&)
 BOOST_DECL_TRANSFORM_TEST(add_reference_test_11, ::boost::add_reference, volatile*, volatile*&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_12, ::boost::add_reference, const[2][3], const (&)[2][3])
+//BOOST_DECL_TRANSFORM_TEST(add_reference_test_12, ::boost::add_reference, const[2][3], const (&)[2][3])
 BOOST_DECL_TRANSFORM_TEST(add_reference_test_13, ::boost::add_reference, (&)[2], (&)[2])

 void check_add_reference()
@ -306,7 +306,7 @@ void check_add_reference()
   add_reference_test_9();
   add_reference_test_10();
   add_reference_test_11();
-   add_reference_test_12();
+   //add_reference_test_12();
   add_reference_test_13();
 }

@ -351,6 +351,88 @@ void check_add_pointer()
 #endif
 }

+/***********************************************************************
+ *
+ * tests for add_const:
+ *
+ **********************************************************************/
+
+BOOST_DECL_TRANSFORM_TEST(add_const_test_1, ::boost::add_const, const, const)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_2, ::boost::add_const, volatile, volatile const)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_3, ::boost::add_const, *, *const)
+//BOOST_DECL_TRANSFORM_TEST2(add_const_test_4, ::boost::add_const)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_7, ::boost::add_const, *volatile, *volatile const)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_10, ::boost::add_const, const*, const*const)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_11, ::boost::add_const, volatile*, volatile*const)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_DECL_TRANSFORM_TEST(add_const_test_5, ::boost::add_const, const &, const&)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_6, ::boost::add_const, &, &)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_8, ::boost::add_const, const [2], const [2])
+BOOST_DECL_TRANSFORM_TEST(add_const_test_9, ::boost::add_const, volatile &, volatile&)
+BOOST_DECL_TRANSFORM_TEST(add_const_test_12, ::boost::add_const, [2][3], const[2][3])
+BOOST_DECL_TRANSFORM_TEST(add_const_test_13, ::boost::add_const, (&)[2], (&)[2])
+#endif
+
+void check_add_const()
+{
+   add_const_test_1();
+   add_const_test_2();
+   add_const_test_3();
+   //add_const_test_4();
+   add_const_test_7();
+   add_const_test_10();
+   add_const_test_11();
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   add_const_test_5();
+   add_const_test_6();
+   add_const_test_8();
+   add_const_test_9();
+   add_const_test_12();
+   add_const_test_13();
+#endif
+}
+
+/***********************************************************************
+ *
+ * tests for add_volatile:
+ *
+ **********************************************************************/
+
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_1, ::boost::add_volatile, const, const volatile)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_2, ::boost::add_volatile, volatile, volatile)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_3, ::boost::add_volatile, *, *volatile)
+//BOOST_DECL_TRANSFORM_TEST2(add_volatile_test_4, ::boost::add_volatile)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_7, ::boost::add_volatile, *volatile, *volatile)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_10, ::boost::add_volatile, const*, const*volatile)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_11, ::boost::add_volatile, volatile*, volatile*volatile)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_5, ::boost::add_volatile, const &, const&)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_6, ::boost::add_volatile, &, &)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_8, ::boost::add_volatile, const [2], const volatile [2])
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_9, ::boost::add_volatile, volatile &, volatile&)
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_12, ::boost::add_volatile, [2][3], volatile[2][3])
+BOOST_DECL_TRANSFORM_TEST(add_volatile_test_13, ::boost::add_volatile, (&)[2], (&)[2])
+#endif
+
+void check_add_volatile()
+{
+   add_volatile_test_1();
+   add_volatile_test_2();
+   add_volatile_test_3();
+   //add_volatile_test_4();
+   add_volatile_test_7();
+   add_volatile_test_10();
+   add_volatile_test_11();
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   add_volatile_test_5();
+   add_volatile_test_6();
+   add_volatile_test_8();
+   add_volatile_test_9();
+   add_volatile_test_12();
+   add_volatile_test_13();
+#endif
+}
+

 int main(int argc, char* argv[])
 {
@ -362,6 +444,8 @@ int main(int argc, char* argv[])
   check_remove_pointer();
   check_add_reference();
   check_add_pointer();
+   check_add_const();
+   check_add_volatile();

   type_test(void, boost::remove_const<void>::type)
   type_test(void, boost::remove_volatile<void>::type)
@ -382,8 +466,10 @@ int main(int argc, char* argv[])
 #ifdef SHORT_TRANSFORM_TEST
 unsigned int expected_failures = 97; // cv-qualifiers
 #else
-unsigned int expected_failures = 422; // cv-qualifiers
+unsigned int expected_failures = 474; // cv-qualifiers
 #endif
+#elif defined(BOOST_MSVC)
+unsigned int expected_failures = 84; // partial specialisation (fails for UDT's)
 #elif defined(__GNUC__)
 unsigned int expected_failures = 1; // cv-qualified references
 #else
@ -393,3 +479,8 @@ unsigned int expected_failures = 0;



+
+
+
+
+
--- a/tools/specialisations.cpp
+++ b/tools/specialisations.cpp
@ -0,0 +1,121 @@
+
+//  (C) Copyright 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.
+
+//
+// Simple program to output some template specialisations for the type_traits library.
+//
+
+#include <fstream>
+
+using namespace std;
+
+unsigned count = 30;
+
+int main()
+{
+   unsigned i, j;
+   ofstream os("specialisations");
+
+   //
+   // generate is_function tester prototypes:
+   for(i = 0; i <= count; ++i)
+   {
+      os << "template <class R";
+      for(j = 0; j < i; ++j)
+      {
+         os << ", class A" << j;
+      }
+      os << ">\n::boost::type_traits::yes_type is_function_tester(R (*)(";
+      if(i == 0)
+         os << "void";
+      else
+      {
+         for(j = 0; j < i; ++j)
+         {
+            if(j) os << ", ";
+            os << "A" << j;
+         }
+      }
+      os << "));" << endl;
+   }
+   os << endl << endl;
+   //
+   // generate is_function_helper partial specialisations:
+   //
+   for(i = 0; i < count; ++i)
+   {
+      os << "template <class R";
+      for(j = 0; j < i; ++j)
+      {
+         os << ", class A" << j;
+      }
+      os << ">\nstruct is_function_helper_base<R (*)(";
+      if(i == 0)
+         os << "void";
+      else
+      {
+         for(j = 0; j < i; ++j)
+         {
+            if(j) os << ", ";
+            os << "A" << j;
+         }
+      }
+      os << ")>{ BOOST_STATIC_CONSTANT(bool, value = true); };" << endl;
+   }
+   os << endl << endl;
+
+
+   //
+   // generate is_member_pointer_helper tester prototypes:
+   for(i = 0; i <= count; ++i)
+   {
+      os << "template <class R, class T";
+      for(j = 0; j < i; ++j)
+      {
+         os << ", class A" << j;
+      }
+      os << ">\n::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(";
+      if(i == 0)
+         os << "void";
+      else
+      {
+         for(j = 0; j < i; ++j)
+         {
+            if(j) os << ", ";
+            os << "A" << j;
+         }
+      }
+      os << "));" << endl;
+   }
+   os << endl << endl;
+   //
+   // generate is_member_pointer partial specialisations:
+   //
+   for(i = 0; i < count; ++i)
+   {
+      os << "template <class R, class T";
+      for(j = 0; j < i; ++j)
+      {
+         os << ", class A" << j;
+      }
+      os << ">\nstruct is_member_pointer<R (T::*)(";
+      if(i == 0)
+         os << "void";
+      else
+      {
+         for(j = 0; j < i; ++j)
+         {
+            if(j) os << ", ";
+            os << "A" << j;
+         }
+      }
+      os << ")>{ BOOST_STATIC_CONSTANT(bool, value = true); };" << endl;
+   }
+   os << endl << endl;
+
+
+   return 0;
+}