Rename test, add to test/Jamfile

One dependency less

.travis.yml

@@ -8,8 +8,8 @@
 #
 # Instructions for customizing this script for your library:
 # 
-# 1. Customize the compilers and language levels you want.
-# 2. If you have move than include/, src/, test/, example/, examples/, or
+# 1. Customize the compilers and language levels you want in the 'jobs'.
+# 2. If you have more than include/, src/, test/, example/, examples/, or
 #    tools/ directories, modify your Travis CI project and add the environment
 #    variable DEPINST.  For example if your build uses code in "bench/" and
 #    "fog/" directories, then set DEPINST to the following:
@@ -18,7 +18,6 @@
 #    variables COVERITY_SCAN_TOKEN and COVERITY_SCAN_NOTIFICATION_EMAIL in
 #    your github settings.
 # 4. Enable pull request builds in your boostorg/<library> account.
-# 5. Change the default C++ version in ci/travis/*.sh (search for CXXSTD) if needed.
 #
 # That's it - the scripts will do everything else for you.
 
@@ -56,46 +55,62 @@ script:
   - cd $BOOST_ROOT/libs/$SELF
   - ci/travis/build.sh
 
+#
+# Default toolsets in Ubuntu
+#
+#       trusty xenial bionic
+#        14.04  16.04  18.04
+#       ------ ------ ------
+# clang    3.4    3.8    6.0
+#   gcc  4.8.2  5.3.1  7.3.0
+#
+
+anchors:
+  clang-34: &clang-34 { apt: { packages: [ "clang-3.4" ], sources: [ "llvm-toolchain-trusty-3.4" ] } }
+  clang-38: &clang-38 { apt: { packages: [ "clang-3.8" ], sources: [ "llvm-toolchain-trusty-3.8" ] } }
+  clang-4:  &clang-4  { apt: { packages: [ "clang-4.0" ], sources: [ "llvm-toolchain-trusty-4.0" ] } }
+  clang-5:  &clang-5  { apt: { packages: [ "clang-5.0" ], sources: [ "llvm-toolchain-trusty-5.0" ] } }
+  clang-6:  &clang-6  { apt: { packages: [ "clang-6.0",
+                                           "libstdc++-7-dev",
+                                           "valgrind"  ], sources: [ "llvm-toolchain-trusty-6.0",
+                                                                     "ubuntu-toolchain-r-test"   ] } }
+  gcc-44:   &gcc-44   { apt: { packages: [ "g++-4.4"   ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-46:   &gcc-46   { apt: { packages: [ "g++-4.6"   ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-48:   &gcc-48   { apt: { packages: [ "g++-4.8"   ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-5:    &gcc-5    { apt: { packages: [ "g++-5"     ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-6:    &gcc-6    { apt: { packages: [ "g++-6"     ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-7:    &gcc-7    { apt: { packages: [ "g++-7"     ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-8:    &gcc-8    { apt: { packages: [ "g++-8"     ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+
 jobs:
   include:
-    #################### Jobs to run on every pull request ####################
+    # libstdc++
+    - { os: "linux", env: [ "TOOLSET=gcc-4.4",   "CXXSTD=98,0x"          ], addons: *gcc-44    }
+    - { os: "linux", env: [ "TOOLSET=gcc-4.6",   "CXXSTD=03,0x"          ], addons: *gcc-46    }
+    - { os: "linux", env: [ "TOOLSET=gcc-4.8",   "CXXSTD=03,11"          ], addons: *gcc-48    }
+    - { os: "linux", env: [ "TOOLSET=gcc-5",     "CXXSTD=03,11"          ], addons: *gcc-5     }
+    - { os: "linux", env: [ "TOOLSET=gcc-6",     "CXXSTD=03,11,14"       ], addons: *gcc-6     }
+    - { os: "linux", env: [ "TOOLSET=gcc-7",     "CXXSTD=03,11,14,17"    ], addons: *gcc-7     }
+    - { os: "linux", env: [ "TOOLSET=gcc-8",     "CXXSTD=03,11,14,17,2a" ], addons: *gcc-8     }
+    - { os: "linux", env: [ "TOOLSET=clang-3.4", "CXXSTD=03,11,14"       ], addons: *clang-34  }
+    - { os: "linux", env: [ "TOOLSET=clang-3.8", "CXXSTD=03,11,14"       ], addons: *clang-38  }
+    - { os: "linux", env: [ "TOOLSET=clang-4.0", "CXXSTD=03,11,14"       ], addons: *clang-4   }
+    - { os: "linux", env: [ "TOOLSET=clang-5.0", "CXXSTD=03,11,14,17"    ], addons: *clang-5   }
+    - { os: "linux", env: [ "TOOLSET=clang-6.0", "CXXSTD=03,11,14,17,2a" ], addons: *clang-6   }
+    # libc++
+  # the rvm environment on osx is taking over basic commands like "cd" and breaking things
+  # - { os: "osx"  , env: [ "COMMENT=libc++",
+  #                         "TOOLSET=clang",     "CXXSTD=03,11,14"       ]                     }
+
     - os: linux
       env: 
-        - COMMENT="C++03"
-        - TOOLSET=gcc,gcc-7,clang
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-    - os: linux
-      env: 
-        - COMMENT="C++11"
-        - TOOLSET=gcc,gcc-7,clang
-        - CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-    - os: linux
-      env: 
-        - COMMENT=valgrind
-        - TOOLSET=clang 
-        - B2_VARIANT=variant=debug
-        - TESTFLAGS=testing.launcher=valgrind
-        - VALGRIND_OPTS=--error-exitcode=1
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-            - libstdc++-7-dev
-            - valgrind
-          sources:
-            - llvm-toolchain-trusty-5.0
-            - ubuntu-toolchain-r-test
+        - COMMENT=codecov.io
+        - TOOLSET=gcc-7
+      addons: *gcc-7
+      script:
+        - pushd /tmp && git clone https://github.com/linux-test-project/lcov.git && export PATH=/tmp/lcov/bin:$PATH && which lcov && lcov --version && popd
+        - cd $BOOST_ROOT/libs/$SELF
+        - ci/travis/codecov.sh
 
     - os: linux
       env:
@@ -106,43 +121,23 @@ jobs:
 
     - os: linux
       env:
-        - COMMENT=UBSAN
+        - COMMENT=ubsan
         - B2_VARIANT=variant=debug
-        - TOOLSET=gcc-7
+        - TOOLSET=gcc-8
         - CXXFLAGS="cxxflags=-fno-omit-frame-pointer cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined"
         - LINKFLAGS="linkflags=-fsanitize=undefined linkflags=-fno-sanitize-recover=undefined linkflags=-fuse-ld=gold"
         - UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
+      addons: *gcc-8
 
     - os: linux
-      env: 
-        - COMMENT=CodeCov
-        - TOOLSET=gcc-7
-      addons:
-        apt:
-          packages:
-            - gcc-7
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-      script:
-        - pushd /tmp && git clone https://github.com/linux-test-project/lcov.git && export PATH=/tmp/lcov/bin:$PATH && which lcov && lcov --version && popd
-        - cd $BOOST_ROOT/libs/$SELF
-        - ci/travis/codecov.sh
-
-  # does not work with sources install shell yet: see 
-  # https://travis-ci.org/jeking3/tokenizer/jobs/384903189
-  # for a typical failure
-  # - os: osx
-  #   osx_image: xcode9
-  #   env:
-  #     - TOOLSET=clang
-  #     - CXXSTD=03,11
+      env:
+        - COMMENT=valgrind
+        - TOOLSET=clang-6.0
+        - CXXSTD=03
+        - B2_VARIANT=variant=debug
+        - TESTFLAGS=testing.launcher=valgrind
+        - VALGRIND_OPTS=--error-exitcode=1
+      addons: *clang-6
 
     #################### Jobs to run on pushes to master, develop ###################
 
@@ -151,7 +146,8 @@ jobs:
       if: (env(COVERITY_SCAN_NOTIFICATION_EMAIL) IS present) AND (branch IN (develop, master)) AND (type IN (cron, push))
       env:
         - COMMENT="Coverity Scan"
-        - TOOLSET=gcc
+        - TOOLSET=gcc-7
+      addons: *gcc-7
       script:
         - cd $BOOST_ROOT/libs/$SELF
         - ci/travis/coverity.sh

include/boost/function.hpp

@@ -23,7 +23,7 @@
 #include <functional> // unary_function, binary_function
 
 #include <boost/preprocessor/iterate.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 // Include the prologue here so that the use of file-level iteration
 // in anything that may be included by function_template.hpp doesn't break

include/boost/function/function_base.hpp

@@ -26,13 +26,13 @@
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/composite_traits.hpp>
 #include <boost/ref.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #ifndef BOOST_NO_SFINAE
-#  include "boost/utility/enable_if.hpp"
+#include <boost/type_traits/enable_if.hpp>
 #else
-#  include "boost/mpl/bool.hpp"
+#include <boost/type_traits/integral_constant.hpp>
 #endif
 #include <boost/function_equal.hpp>
 #include <boost/function/function_fwd.hpp>
@@ -50,7 +50,7 @@
 #endif // __ICL etc
 
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_c<          \
+      typename ::boost::enable_if_<          \
                            !(::boost::is_integral<Functor>::value), \
                            Type>::type
 
@@ -152,15 +152,15 @@ namespace boost {
       template<typename F>
       class get_function_tag
       {
-        typedef typename mpl::if_c<(is_pointer<F>::value),
+        typedef typename conditional<(is_pointer<F>::value),
                                    function_ptr_tag,
                                    function_obj_tag>::type ptr_or_obj_tag;
 
-        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+        typedef typename conditional<(is_member_pointer<F>::value),
                                    member_ptr_tag,
                                    ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
 
-        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+        typedef typename conditional<(is_reference_wrapper<F>::value),
                                    function_obj_ref_tag,
                                    ptr_or_obj_or_mem_tag>::type or_ref_tag;
 
@@ -328,7 +328,7 @@ namespace boost {
         // Function objects that fit in the small-object buffer.
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::true_)
+                functor_manager_operation_type op, true_type)
         {
           functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
         }
@@ -336,7 +336,7 @@ namespace boost {
         // Function objects that require heap allocation
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::false_)
+                functor_manager_operation_type op, false_type)
         {
           if (op == clone_functor_tag) {
             // Clone the functor
@@ -377,7 +377,7 @@ namespace boost {
                 functor_manager_operation_type op, function_obj_tag)
         {
           manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
         }
 
         // For member pointers, we use the small-object optimization buffer.
@@ -385,7 +385,7 @@ namespace boost {
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                 functor_manager_operation_type op, member_ptr_tag)
         {
-          manager(in_buffer, out_buffer, op, mpl::true_());
+          manager(in_buffer, out_buffer, op, true_type());
         }
 
       public:
@@ -427,7 +427,7 @@ namespace boost {
         // Function objects that fit in the small-object buffer.
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::true_)
+                functor_manager_operation_type op, true_type)
         {
           functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
         }
@@ -435,7 +435,7 @@ namespace boost {
         // Function objects that require heap allocation
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::false_)
+                functor_manager_operation_type op, false_type)
         {
           typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
@@ -499,7 +499,7 @@ namespace boost {
                 functor_manager_operation_type op, function_obj_tag)
         {
           manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
         }
 
       public:
@@ -530,24 +530,24 @@ namespace boost {
 #ifdef BOOST_NO_SFINAE
       // These routines perform comparisons between a Boost.Function
       // object and an arbitrary function object (when the last
-      // parameter is mpl::bool_<false>) or against zero (when the
-      // last parameter is mpl::bool_<true>). They are only necessary
+      // parameter is false_type) or against zero (when the
+      // last parameter is true_type). They are only necessary
       // for compilers that don't support SFINAE.
       template<typename Function, typename Functor>
         bool
-        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        compare_equal(const Function& f, const Functor&, int, true_type)
         { return f.empty(); }
 
       template<typename Function, typename Functor>
         bool
         compare_not_equal(const Function& f, const Functor&, int,
-                          mpl::bool_<true>)
+                          true_type)
         { return !f.empty(); }
 
       template<typename Function, typename Functor>
         bool
         compare_equal(const Function& f, const Functor& g, long,
-                      mpl::bool_<false>)
+                      false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return function_equal(*fp, g);
@@ -557,7 +557,7 @@ namespace boost {
       template<typename Function, typename Functor>
         bool
         compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, mpl::bool_<false>)
+                      int, false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return fp == g.get_pointer();
@@ -567,7 +567,7 @@ namespace boost {
       template<typename Function, typename Functor>
         bool
         compare_not_equal(const Function& f, const Functor& g, long,
-                          mpl::bool_<false>)
+                          false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return !function_equal(*fp, g);
@@ -578,7 +578,7 @@ namespace boost {
         bool
         compare_not_equal(const Function& f,
                           const reference_wrapper<Functor>& g, int,
-                          mpl::bool_<false>)
+                          false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return fp != g.get_pointer();
@@ -750,28 +750,28 @@ inline bool operator!=(detail::function::useless_clear_type*,
 template<typename Functor>
   inline bool operator==(const function_base& f, Functor g)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_equal(f, g, 0, integral());
   }
 
 template<typename Functor>
   inline bool operator==(Functor g, const function_base& f)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_equal(f, g, 0, integral());
   }
 
 template<typename Functor>
   inline bool operator!=(const function_base& f, Functor g)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_not_equal(f, g, 0, integral());
   }
 
 template<typename Functor>
   inline bool operator!=(Functor g, const function_base& f)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_not_equal(f, g, 0, integral());
   }
 #else

include/boost/function/function_template.hpp

@@ -11,7 +11,7 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@@ -29,8 +29,7 @@
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
 #else
-#   include <boost/move/utility_core.hpp>
-#   define BOOST_FUNCTION_ARG(J,I,D) ::boost::forward< BOOST_PP_CAT(T,I) >(BOOST_PP_CAT(a,I))
+#   define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
 #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
 #endif
 
@@ -240,7 +239,7 @@ namespace boost {
       >
       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                             FunctionPtr,
                             R BOOST_FUNCTION_COMMA
@@ -261,7 +260,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -282,7 +281,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -305,7 +304,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_MEMBER_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_MEMBER_INVOKER<
                             MemberPtr,
                             R BOOST_FUNCTION_COMMA
@@ -567,27 +566,27 @@ namespace boost {
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
         {
           new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
         {
-          assign_functor(f,functor,mpl::true_());
+          assign_functor(f,functor,true_type());
         }
 
         // Assign to a function object allocated on the heap.
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
         {
           functor.members.obj_ptr = new FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
         {
           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
@@ -615,7 +614,7 @@ namespace boost {
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor(f, functor,
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -627,7 +626,7 @@ namespace boost {
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor_a(f, functor, a,
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -708,14 +707,14 @@ namespace boost {
 
     typedef BOOST_FUNCTION_FUNCTION self_type;
 
-    BOOST_FUNCTION_FUNCTION() : function_base() { }
+    BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {})
 
     // MSVC chokes if the following two constructors are collapsed into
     // one with a default parameter.
     template<typename Functor>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_c<
+                            ,typename boost::enable_if_<
                              !(is_integral<Functor>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
@@ -727,7 +726,7 @@ namespace boost {
     template<typename Functor,typename Allocator>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_c<
+                            ,typename boost::enable_if_<
                               !(is_integral<Functor>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
@@ -776,7 +775,7 @@ namespace boost {
     // construct.
     template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-    typename boost::enable_if_c<
+    typename boost::enable_if_<
                   !(is_integral<Functor>::value),
                BOOST_FUNCTION_FUNCTION&>::type
 #else
@@ -1046,7 +1045,7 @@ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
 #else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
 #endif
 
 template<typename R BOOST_FUNCTION_COMMA
@@ -1061,12 +1060,12 @@ class function<BOOST_FUNCTION_PARTIAL_SPEC>
 
 public:
 
-  function() : base_type() {}
+  BOOST_DEFAULTED_FUNCTION(function(), : base_type() {})
 
   template<typename Functor>
   function(Functor f
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_c<
+           ,typename boost::enable_if_<
                           !(is_integral<Functor>::value),
                        int>::type = 0
 #endif
@@ -1077,7 +1076,7 @@ public:
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_c<
+           ,typename boost::enable_if_<
                            !(is_integral<Functor>::value),
                        int>::type = 0
 #endif
@@ -1116,7 +1115,7 @@ public:
 
   template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-  typename boost::enable_if_c<
+  typename boost::enable_if_<
                          !(is_integral<Functor>::value),
                       self_type&>::type
 #else

test/Jamfile.v2

@@ -7,69 +7,34 @@
 
 # For more information, see http://www.boost.org/
 
-project
-    : requirements <toolset>msvc:<asynch-exceptions>on
-    : source-location $(BOOST_ROOT)
-    ;
-
-# bring in rules for testing
 import testing ;
 
-{
+run function_test.cpp ;
+# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
+run function_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : function_test_no_rtti ;
+run function_n_test.cpp ;
+run allocator_test.cpp ;
+run stateless_test.cpp ;
+run lambda_test.cpp ;
+compile-fail function_test_fail1.cpp ;
+compile-fail function_test_fail2.cpp ;
+compile function_30.cpp ;
+compile function_30_repeat.cpp ;
+run function_arith_cxx98.cpp ;
+run function_arith_portable.cpp ;
+run sum_avg_cxx98.cpp ;
+run sum_avg_portable.cpp ;
+run mem_fun_cxx98.cpp ;
+run mem_fun_portable.cpp ;
+run std_bind_cxx98.cpp ;
+run std_bind_portable.cpp ;
+run function_ref_cxx98.cpp ;
+run function_ref_portable.cpp ;
+run contains_test.cpp ;
+run contains2_test.cpp ;
+run nothrow_swap.cpp ;
+run rvalues_test.cpp ;
+compile function_typeof_test.cpp ;
+run result_arg_types_test.cpp ;
 
-  test-suite function
-    : 
-  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
-
-  [ run libs/function/test/function_test.cpp :  :  : <rtti>off : lib_function_test_no_rtti ]
-
-  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
-
-  [ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
-
-  [ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-
-  [ compile libs/function/test/function_30_repeat.cpp :  :  :  :  ] 
-
-  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
-  
-  [ run libs/function/test/contains_test.cpp : : : : ]
-   
-  [ run libs/function/test/contains2_test.cpp : : : : ]
-   
-  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
-
-  [ run libs/function/test/rvalues_test.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_typeof_test.cpp ]
-
-  [ run libs/function/test/result_arg_types_test.cpp ]
- ;
-}
-      
+run boost_test_ubsan.cpp /boost/test//boost_unit_test_framework ;

test/allocator_test.cpp

@@ -7,10 +7,10 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/test/minimal.hpp>
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 #include <functional>
-#include <boost/function.hpp>
 
 using namespace std;
 using namespace boost;
@@ -74,20 +74,19 @@ struct DoNothing: base
 
 static void do_nothing() {}
 
-int
-test_main(int, char*[])
+int main()
 {
   function2<int, int, int> f;
   f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
   f.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
+  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_TEST_EQ( dealloc_count, 1 );
   alloc_count = 0;
   dealloc_count = 0;
   f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
   f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
   f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
   f.clear();
   f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
@@ -97,8 +96,8 @@ test_main(int, char*[])
   dealloc_count = 0;
   f.assign( &do_minus, counting_allocator<int>() );
   f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
   f.assign( &do_minus, std::allocator<int>() );
   f.clear();
 
@@ -107,14 +106,14 @@ test_main(int, char*[])
   dealloc_count = 0;
   fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
   fv.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
+  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_TEST_EQ( dealloc_count, 1 );
   alloc_count = 0;
   dealloc_count = 0;
   fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
   fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
   fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
   fv.clear();
   fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
@@ -124,8 +123,8 @@ test_main(int, char*[])
   dealloc_count = 0;
   fv.assign( &do_nothing, counting_allocator<int>() );
   fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
   fv.assign( &do_nothing, std::allocator<int>() );
   fv.clear();
   
@@ -133,5 +132,5 @@ test_main(int, char*[])
   fv.assign(&do_nothing, std::allocator<int>() );
   fv2.assign(fv, std::allocator<int>() );
 
-  return 0;
+  return boost::report_errors();
 }

test/boost_test_ubsan.cpp

@@ -0,0 +1,11 @@
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE( ubsan_tests )
+
+BOOST_AUTO_TEST_CASE( test1 )
+{
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/contains2_test.cpp

@@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 static int forty_two()
 {

test/function_n_test.cpp

@@ -631,7 +631,7 @@ test_ref()
     boost::function2<int, int, int> f(ref(atc));
     BOOST_CHECK(f(1, 3) == 4);
   }
-  catch(std::runtime_error e) {
+  catch(std::runtime_error const&) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }

test/function_test.cpp

@@ -624,7 +624,7 @@ test_ref()
     boost::function<int (int, int)> f(boost::ref(atc));
     BOOST_CHECK(f(1, 3) == 4);
   }
-  catch(std::runtime_error e) {
+  catch(std::runtime_error const&) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
@@ -651,14 +651,14 @@ static void test_empty_ref()
     f2();
     BOOST_ERROR("Exception didn't throw for reference to empty function.");
   }
-  catch(std::runtime_error e) {}
+  catch(std::runtime_error const&) {}
 
   f1 = dummy;
 
   try {
     f2();
   }
-  catch(std::runtime_error e) {
+  catch(std::runtime_error const&) {
     BOOST_ERROR("Error calling referenced function.");
   }
 }
@@ -673,7 +673,7 @@ static void test_exception()
     f(5, 4);
     BOOST_CHECK(false);
   }
-  catch(boost::bad_function_call) {
+  catch(boost::bad_function_call const&) {
     // okay
   }
 }

test/lambda_test.cpp

@@ -7,13 +7,13 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/function.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/lambda/bind.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <cstdlib>
 
-#include <boost/test/minimal.hpp>
-#include <boost/lambda/lambda.hpp>
-#include <boost/lambda/bind.hpp>
-#include <boost/function.hpp>
 
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
@@ -22,17 +22,19 @@ func_impl(int arg1, bool arg2, double arg3)
   return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }
 
-int test_main(int, char*[])
+int main()
 {
   using boost::function;
   using namespace boost::lambda;
 
   function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
+  BOOST_TEST_EQ( f1(true, 2.0), 30 );
+
   function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
+  BOOST_TEST_EQ( f2(2.0), 60 );
+
   function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
+  BOOST_TEST_EQ( f3(), 120 );
 
-  f3();
-
-  return 0;
+  return boost::report_errors();
 }
-

test/mem_fun_cxx98.cpp

@@ -10,7 +10,7 @@
 
     
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <functional>
 

test/mem_fun_portable.cpp

@@ -10,7 +10,7 @@
 
     
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <functional>
 

test/stateless_test.cpp

@@ -7,16 +7,18 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <stdexcept>
+#include <new>
 
 struct stateless_integer_add {
   int operator()(int x, int y) const { return x+y; }
 
-  void* operator new(std::size_t)
+  void* operator new(std::size_t n)
   {
-    throw std::runtime_error("Cannot allocate a stateless_integer_add");
+    BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
+    return ::operator new( n );
   }
 
   void* operator new(std::size_t, void* p)
@@ -24,15 +26,17 @@ struct stateless_integer_add {
     return p;
   }
 
-  void operator delete(void*) throw()
+  void operator delete(void* p) throw()
   {
+    BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
+    return ::operator delete( p );
   }
 };
 
-int test_main(int, char*[])
+int main()
 {
   boost::function2<int, int, int> f;
   f = stateless_integer_add();
 
-  return 0;
+  return boost::report_errors();
 }