diff --git a/doc/07_converters.qbk b/doc/07_converters.qbk
index 33a07af..bf8cc0a 100644
--- a/doc/07_converters.qbk
+++ b/doc/07_converters.qbk
@@ -1,6 +1,6 @@
 [section Converters]
 
-The ['Boost.Convert] facade API plays an important role as it is responsible for and provides a uniform interface and ensures consistent behavior. However, it is the respective plugged-in converter who does the hard work of turning integers into strings and strings into custom-types, etc., i.e. the hard work of actual type conversion\/transformation. 
+The ['Boost.Convert] facade API plays an important role as it is responsible for and provides a uniform interface and ensures consistent behavior. However, it is the respective plugged-in converter who does the hard work of turning custom-types into strings and strings into custom-types, etc., i.e. the hard work of actual type conversion\/transformation. 
 
 For a converter to be plugged in to the ['Boost.Convert] framework it needs to be a ['callable] with the following signature:
 
diff --git a/include/boost/convert/api.hpp b/include/boost/convert/api.hpp
index 9142e49..27d6c99 100644
--- a/include/boost/convert/api.hpp
+++ b/include/boost/convert/api.hpp
@@ -1,16 +1,13 @@
-/// \file boost/convert.hpp
-/// Public interface to the Boost.Convert framework.
-//
 // Boost.Convert library
 // Copyright (c) 2009-2014 Vladimir Batov.
 //
 // Many thanks to 
-// Andrzej Krzemienski for helping great deal to partition responsibilities and to ultimately pave
-// the way for the tr1::optional deployment;
-// Edward Diener the Boost Review Manager for helping with the converters' design, his continuous
-// involvement, technical and administrative help, guidance and advice;
-// Kevlin Henney and Dave Abrahams for their ['lexical_cast]-related insights and explanations;
-// Rob Stewart and Alex Hagen-Zanker for making sure the performance tests work as they should.
+// *) Andrzej Krzemienski for helping great deal to partition responsibilities and to ultimately pave
+//    the way for the tr1::optional deployment;
+// *) Edward Diener the Boost Review Manager for helping with the converters' design, his continuous
+//    involvement, technical and administrative help, guidance and advice;
+// *) Kevlin Henney and Dave Abrahams for their ['lexical_cast]-related insights and explanations;
+// *) Rob Stewart and Alex Hagen-Zanker for making sure the performance tests work as they should.
 // 
 // Use, modification and distribution are subject to the Boost Software License,
 // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
@@ -18,9 +15,9 @@
 #ifndef BOOST_CONVERT_API_HPP
 #define BOOST_CONVERT_API_HPP
 
-#include "./detail/safebool.hpp"
-#include "./detail/workarounds.hpp"
-#include "./detail/string.hpp"
+#include <boost/convert/detail/safebool.hpp>
+#include <boost/convert/detail/workarounds.hpp>
+#include <boost/convert/detail/string.hpp>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
diff --git a/include/boost/convert/converter/base.hpp b/include/boost/convert/converter/base.hpp
index fb3c160..b2cb647 100644
--- a/include/boost/convert/converter/base.hpp
+++ b/include/boost/convert/converter/base.hpp
@@ -6,7 +6,7 @@
 #ifndef BOOST_CONVERT_CONVERTER_BASE_HPP
 #define BOOST_CONVERT_CONVERTER_BASE_HPP
 
-#include "../parameters.hpp"
+#include <boost/convert/parameters.hpp>
 
 namespace boost 
 {
@@ -61,4 +61,8 @@ struct boost::converter_base
     operator()(parameter::aux::tag<conversion::parameter::type::uppercase, bool const>::type const& arg) const              \
     { return (base_type::operator()(arg), *this);  }
 
+#define CONVERTER_PARAM_FUNC(PARAM_NAME, PARAM_TYPE)    \
+    this_type&                                          \
+    operator()(boost::parameter::aux::tag<boost::conversion::parameter::type::PARAM_NAME, PARAM_TYPE const>::type const& arg)
+
 #endif // BOOST_CONVERT_CONVERTER_BASE_HPP
diff --git a/include/boost/convert/converter/printf.hpp b/include/boost/convert/converter/printf.hpp
index 10425ea..7e3d8a3 100644
--- a/include/boost/convert/converter/printf.hpp
+++ b/include/boost/convert/converter/printf.hpp
@@ -6,7 +6,7 @@
 #ifndef BOOST_CONVERT_PRINTF_CONVERTER_HPP
 #define BOOST_CONVERT_PRINTF_CONVERTER_HPP
 
-#include "./base.hpp"
+#include <boost/convert/converter/base.hpp>
 #include <stdio.h>
 
 namespace boost 
diff --git a/include/boost/convert/converter/sstream.hpp b/include/boost/convert/converter/sstream.hpp
index f2d94a5..5070394 100644
--- a/include/boost/convert/converter/sstream.hpp
+++ b/include/boost/convert/converter/sstream.hpp
@@ -6,8 +6,8 @@
 #ifndef BOOST_CONVERT_STRINGSTREAM_BASED_CONVERTER_HPP
 #define BOOST_CONVERT_STRINGSTREAM_BASED_CONVERTER_HPP
 
-#include "../detail/string.hpp"
-#include "../detail/details.hpp"
+#include <boost/convert/converter/base.hpp>
+#include <boost/convert/detail/string.hpp>
 #include <sstream>
 
 namespace boost 
@@ -105,6 +105,4 @@ struct boost::basic_stringstream_converter
     mutable stream_type stream_;
 };
 
-#undef CONVERTER_PARAM_FUNC
-
 #endif // BOOST_CONVERT_STRINGSTREAM_BASED_CONVERTER_HPP
diff --git a/include/boost/convert/converter/strtol.hpp b/include/boost/convert/converter/strtol.hpp
index 8ef45a4..fcbd106 100644
--- a/include/boost/convert/converter/strtol.hpp
+++ b/include/boost/convert/converter/strtol.hpp
@@ -7,7 +7,7 @@
 #ifndef BOOST_CONVERT_STRTOL_CONVERTER_HPP
 #define BOOST_CONVERT_STRTOL_CONVERTER_HPP
 
-#include "./base.hpp"
+#include <boost/convert/converter/base.hpp>
 #include <stdlib.h>
 
 namespace boost 
diff --git a/include/boost/convert/detail/boost_parameter_ext.hpp b/include/boost/convert/detail/boost_parameter_ext.hpp
index 224181c..1f77f8e 100644
--- a/include/boost/convert/detail/boost_parameter_ext.hpp
+++ b/include/boost/convert/detail/boost_parameter_ext.hpp
@@ -1,5 +1,5 @@
-#ifndef __BOOST_PARAMETER_EXT_PRIVATE_HPP__
-#define __BOOST_PARAMETER_EXT_PRIVATE_HPP__
+#ifndef BOOST_PARAMETER_EXT_PRIVATE_HPP
+#define BOOST_PARAMETER_EXT_PRIVATE_HPP
 
 #include <boost/parameter/keyword.hpp>
 
@@ -54,5 +54,5 @@ struct parameter_type<
 
 }} // boost::parameter
 
-#endif // __BOOST_PARAMETER_EXT_PRIVATE_HPP__
+#endif // BOOST_PARAMETER_EXT_PRIVATE_HPP
 
diff --git a/include/boost/convert/detail/details.hpp b/include/boost/convert/detail/details.hpp
deleted file mode 100644
index 5293ee4..0000000
--- a/include/boost/convert/detail/details.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// Boost.Convert library
-// Copyright (c) 2009-2014 Vladimir Batov.
-// Use, modification and distribution are subject to the Boost Software License,
-// Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
-
-#ifndef BOOST_CONVERT_DETAILS_HPP
-#define BOOST_CONVERT_DETAILS_HPP
-
-#include "../parameters.hpp"
-
-#define CONVERTER_PARAM_FUNC(PARAM_NAME, PARAM_TYPE)    \
-    this_type&                                          \
-    operator()(boost::parameter::aux::tag<boost::conversion::parameter::type::PARAM_NAME, PARAM_TYPE const>::type const& arg)
-
-#endif // BOOST_CONVERT_DETAILS_HPP
diff --git a/include/boost/convert/detail/string.hpp b/include/boost/convert/detail/string.hpp
index dd8e6c9..f147052 100644
--- a/include/boost/convert/detail/string.hpp
+++ b/include/boost/convert/detail/string.hpp
@@ -5,8 +5,8 @@
 // Use, modification and distribution are subject to the Boost Software License,
 // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
 
-#ifndef __BOOST_CONVERT_STRING_SFINAE_HPP__
-#define __BOOST_CONVERT_STRING_SFINAE_HPP__
+#ifndef BOOST_CONVERT_DETAIL_STRING_SFINAE_HPP
+#define BOOST_CONVERT_DETAIL_STRING_SFINAE_HPP
 
 #include <boost/type_traits.hpp>
 #include <boost/type_traits/decay.hpp>
@@ -144,4 +144,4 @@ struct corrected<String, typename boost::enable_if<is_any_string<String> >::type
 
 }}
 
-#endif // __BOOST_CONVERT_STRING_SFINAE_HPP__
+#endif // BOOST_CONVERT_DETAIL_STRING_SFINAE_HPP
diff --git a/include/boost/convert/detail/workarounds.hpp b/include/boost/convert/detail/workarounds.hpp
index 075ee3d..39ea667 100644
--- a/include/boost/convert/detail/workarounds.hpp
+++ b/include/boost/convert/detail/workarounds.hpp
@@ -4,8 +4,8 @@
 // Use, modification and distribution are subject to the Boost Software License,
 // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
 
-#ifndef __BOOST_CONVERT_WORKAROUNDS_PRIVATE_HPP__
-#define __BOOST_CONVERT_WORKAROUNDS_PRIVATE_HPP__
+#ifndef BOOST_CONVERT_DETAIL_WORKAROUNDS_HPP
+#define BOOST_CONVERT_DETAIL_WORKAROUNDS_HPP
 
 #include <boost/version.hpp>
 
@@ -17,4 +17,4 @@
 #   define snprintf _snprintf
 #endif
 
-#endif // __BOOST_CONVERT_WORKAROUNDS_PRIVATE_HPP__
+#endif // BOOST_CONVERT_DETAIL_WORKAROUNDS_HPP
diff --git a/include/boost/convert/parameters.hpp b/include/boost/convert/parameters.hpp
index 0a67b03..5ba23ce 100644
--- a/include/boost/convert/parameters.hpp
+++ b/include/boost/convert/parameters.hpp
@@ -6,7 +6,7 @@
 #ifndef BOOST_CONVERT_PARAMETERS_HPP
 #define BOOST_CONVERT_PARAMETERS_HPP
 
-#include "./detail/boost_parameter_ext.hpp"
+#include <boost/convert/detail/boost_parameter_ext.hpp>
 
 namespace boost
 {
diff --git a/test/algorithms.cpp b/test/algorithms.cpp
index d12d69e..46e4c06 100644
--- a/test/algorithms.cpp
+++ b/test/algorithms.cpp
@@ -25,12 +25,12 @@ test::algorithms()
             std::back_inserter(integers),
             boost::bind(boost::lexical_cast<int, std::string>, _1));
 
-        BOOST_ASSERT(!"Failed to throw");
+        BOOST_TEST(!"Failed to throw");
     }
     catch (std::exception&)
     {
         // Expected behavior.
-        BOOST_ASSERT(integers.size() == 0);
+        BOOST_TEST(integers.size() == 0);
     }
     try
     {
@@ -40,17 +40,17 @@ test::algorithms()
             std::back_inserter(integers),
             boost::convert<int>::from<std::string>(ccnv(std::hex)));
 
-        BOOST_ASSERT(!"Failed to throw");
+        BOOST_TEST(!"Failed to throw");
     }
     catch (std::exception&)
     {
         // Expected behavior.
-        BOOST_ASSERT(integers.size() == 4);
+        BOOST_TEST(integers.size() == 4);
     }
-    BOOST_ASSERT(integers[0] == 15);
-    BOOST_ASSERT(integers[1] == 16);
-    BOOST_ASSERT(integers[2] == 17);
-    BOOST_ASSERT(integers[3] == 18);
+    BOOST_TEST(integers[0] == 15);
+    BOOST_TEST(integers[1] == 16);
+    BOOST_TEST(integers[2] == 17);
+    BOOST_TEST(integers[3] == 18);
 
     integers.clear();
 
@@ -64,12 +64,12 @@ test::algorithms()
         std::back_inserter(integers),
         boost::convert<int>::from<std::string>(ccnv(arg::base = cnv::base::hex)).value_or(-1));
 
-    BOOST_ASSERT(integers.size() == 5);
-    BOOST_ASSERT(integers[0] == 15);
-    BOOST_ASSERT(integers[1] == 16);
-    BOOST_ASSERT(integers[2] == 17);
-    BOOST_ASSERT(integers[3] == 18);
-    BOOST_ASSERT(integers[4] == -1); // Failed conversion
+    BOOST_TEST(integers.size() == 5);
+    BOOST_TEST(integers[0] == 15);
+    BOOST_TEST(integers[1] == 16);
+    BOOST_TEST(integers[2] == 17);
+    BOOST_TEST(integers[3] == 18);
+    BOOST_TEST(integers[4] == -1); // Failed conversion
 
 #ifdef NOT_AVAILABLE_UNTIL_CPP11
 
@@ -81,16 +81,16 @@ test::algorithms()
         std::back_inserter(opt_ints),
         boost::convert<int>::from<std::string>(ccnv(arg::base = cnv::base::hex)));
 
-    BOOST_ASSERT(opt_ints.size() == 5);
-    BOOST_ASSERT( opt_ints[0]);
-    BOOST_ASSERT( opt_ints[1]);
-    BOOST_ASSERT( opt_ints[2]);
-    BOOST_ASSERT( opt_ints[3]);
-    BOOST_ASSERT(!opt_ints[4]); // Failed conversion
-    BOOST_ASSERT(opt_ints[0].value() == 15);
-    BOOST_ASSERT(opt_ints[1].value() == 16);
-    BOOST_ASSERT(opt_ints[2].value() == 17);
-    BOOST_ASSERT(opt_ints[3].value() == 18);
+    BOOST_TEST(opt_ints.size() == 5);
+    BOOST_TEST( opt_ints[0]);
+    BOOST_TEST( opt_ints[1]);
+    BOOST_TEST( opt_ints[2]);
+    BOOST_TEST( opt_ints[3]);
+    BOOST_TEST(!opt_ints[4]); // Failed conversion
+    BOOST_TEST(opt_ints[0].value() == 15);
+    BOOST_TEST(opt_ints[1].value() == 16);
+    BOOST_TEST(opt_ints[2].value() == 17);
+    BOOST_TEST(opt_ints[3].value() == 18);
 
 #endif
 
@@ -104,12 +104,12 @@ test::algorithms()
         std::back_inserter(new_strings),
         boost::convert<std::string>::from<int>(ccnv(std::dec)));
 
-    BOOST_ASSERT(new_strings.size() == 5);
-    BOOST_ASSERT(new_strings[0] == "15");
-    BOOST_ASSERT(new_strings[1] == "16");
-    BOOST_ASSERT(new_strings[2] == "17");
-    BOOST_ASSERT(new_strings[3] == "18");
-    BOOST_ASSERT(new_strings[4] == "-1");
+    BOOST_TEST(new_strings.size() == 5);
+    BOOST_TEST(new_strings[0] == "15");
+    BOOST_TEST(new_strings[1] == "16");
+    BOOST_TEST(new_strings[2] == "17");
+    BOOST_TEST(new_strings[3] == "18");
+    BOOST_TEST(new_strings[4] == "-1");
 
 
 
diff --git a/test/callable.cpp b/test/callable.cpp
new file mode 100644
index 0000000..84da01f
--- /dev/null
+++ b/test/callable.cpp
@@ -0,0 +1,49 @@
+// Boost.Convert library test and usage example
+// Copyright (c) 2009-2014 Vladimir Batov.
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
+
+#include "./test.hpp"
+#include <boost/function.hpp>
+
+static
+bool
+plain_old_func(std::string const& value_in, int& value_out)
+{
+    try
+    {
+        value_out = boost::lexical_cast<int>(value_in);
+        return true;
+    }
+    catch (...)
+    {
+        return false;
+    }
+}
+
+template<typename Type>
+bool
+assign(Type& value_out, Type const& value_in)
+{
+    value_out = value_in;
+    return true;
+}
+
+void
+test::callables()
+{
+    typedef boost::function<bool (std::string const& value_in, int&)> boost_func;
+
+    char const* const str = "-12";
+
+    // Testing old-function-based converter.
+    int v01 = convert<int>::from(str, plain_old_func).value_or(-1);
+    // Testing boost::function-based converter.
+    int v02 = convert<int>::from(str, boost_func(plain_old_func)).value_or(-1);
+    // Testing crazy boost::bind-based converter.
+    int v03 = convert<int>::from(str, boost::bind(assign<int>, _2, boost::bind(boost::lexical_cast<int, std::string>, _1))).value_or(-1);
+
+    BOOST_TEST(v01 == -12);
+    BOOST_TEST(v02 == -12);
+    BOOST_TEST(v03 == -12);
+}
diff --git a/test/encryption.cpp b/test/encryption.cpp
index 6b330d8..ff57582 100644
--- a/test/encryption.cpp
+++ b/test/encryption.cpp
@@ -28,6 +28,6 @@ test::encryption()
     string encrypted = convert<string>::from("ABC", my_cypher).value();
     string decrypted = convert<string>::from(encrypted, my_cypher).value();
 
-    BOOST_ASSERT(encrypted == "123");
-    BOOST_ASSERT(decrypted == "ABC");
+    BOOST_TEST(encrypted == "123");
+    BOOST_TEST(decrypted == "ABC");
 }
diff --git a/test/performance.cpp b/test/performance.cpp
index b72f718..b283c1f 100644
--- a/test/performance.cpp
+++ b/test/performance.cpp
@@ -18,12 +18,12 @@ performance_string_to_type(Converter const& try_converter)
         change chg = boost::convert<change>::from(input[k % 3], try_converter).value();
         int    res = chg.value();
 
-        BOOST_ASSERT(res == k % 3);
+        BOOST_TEST(res == k % 3);
 
         sum += res; // Make sure dir is not optimized out
     }
     double   p2 = clock();
-    int use_sum = (sum % 2) ? 0 : (sum % 2); BOOST_ASSERT(use_sum == 0);
+    int use_sum = (sum % 2) ? 0 : (sum % 2); BOOST_TEST(use_sum == 0);
 
     return (p2 - p1) / CLOCKS_PER_SEC + use_sum;
 }
@@ -40,7 +40,7 @@ performance_string_to_int(Converter const& try_converter)
         sum += boost::convert<int>::from((str[4 - k % 5] = 49 + k % 9, str), try_converter).value();
 
     double   p2 = clock();
-    int use_sum = (sum % 2) ? 0 : (sum % 2); BOOST_ASSERT(use_sum == 0);
+    int use_sum = (sum % 2) ? 0 : (sum % 2); BOOST_TEST(use_sum == 0);
 
     return (p2 - p1) / CLOCKS_PER_SEC + use_sum;
 }
@@ -58,7 +58,7 @@ performance_int_to_string(Converter const& try_converter)
     double p2 = clock();
 
     for (int k = 0; k < test::num_cycles; ++k)
-        BOOST_ASSERT(k == boost::convert<int>::from(res[k], try_converter).value());
+        BOOST_TEST(k == boost::convert<int>::from(res[k], try_converter).value());
 
     return (p2 - p1) / CLOCKS_PER_SEC;
 }
diff --git a/test/sfinae.cpp b/test/sfinae.cpp
index 9c24793..959f05e 100644
--- a/test/sfinae.cpp
+++ b/test/sfinae.cpp
@@ -23,14 +23,14 @@ test::sfinae()
     bool q98 = boost::convert_detail::is_any_string<int>::value;
     bool q99 = boost::convert_detail::is_any_string<direction>::value;
 
-    BOOST_ASSERT( q01);
-    BOOST_ASSERT( q02);
-    BOOST_ASSERT( q03);
-    BOOST_ASSERT( q04);
-    BOOST_ASSERT( q05);
-    BOOST_ASSERT( q06);
-    BOOST_ASSERT(!q07); // Support withdrawn. So, evaluates to false.
-    BOOST_ASSERT(!q08); // Support withdrawn. So, evaluates to false.
-    BOOST_ASSERT(!q98);
-    BOOST_ASSERT(!q99);
+    BOOST_TEST( q01);
+    BOOST_TEST( q02);
+    BOOST_TEST( q03);
+    BOOST_TEST( q04);
+    BOOST_TEST( q05);
+    BOOST_TEST( q06);
+    BOOST_TEST(!q07); // Support withdrawn. So, evaluates to false.
+    BOOST_TEST(!q08); // Support withdrawn. So, evaluates to false.
+    BOOST_TEST(!q98);
+    BOOST_TEST(!q99);
 }
diff --git a/test/test.hpp b/test/test.hpp
index 7b7d351..b760433 100644
--- a/test/test.hpp
+++ b/test/test.hpp
@@ -8,6 +8,7 @@
 #include <boost/convert/converter/strtol.hpp>
 #include <boost/array.hpp>
 #include <boost/bind.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iomanip>
 #include <vector>
 #include <list>
@@ -93,10 +94,11 @@ struct test
 #error "Add here."
 #endif
 
-    static void      sfinae();
-    static void  algorithms();
-    static void performance();
-    static void encryption ();
+    static void      sfinae ();
+    static void  algorithms ();
+    static void performance ();
+    static void  encryption ();
+    static void   callables ();
 
 	template<typename Converter> static void type_to_string(Converter const&);
 	template<typename Converter> static void string_to_type(Converter const&);
diff --git a/test/test_convert.cpp b/test/test_convert.cpp
index 995dfc8..2a19318 100644
--- a/test/test_convert.cpp
+++ b/test/test_convert.cpp
@@ -9,6 +9,7 @@
 #include "./algorithms.cpp"
 #include "./performance.cpp"
 #include "./encryption.cpp"
+#include "./callable.cpp"
 #endif
 
 using std::string;
@@ -19,28 +20,20 @@ template<typename Converter>
 void
 test::type_to_string(Converter const& cnv)
 {
-    BOOST_ASSERT("255" == boost::convert<std::string>::from(255, cnv(arg::base = cnv::base::dec)).value_or("bad"));
-    BOOST_ASSERT( "ff" == boost::convert<std::string>::from(255, cnv(arg::base = cnv::base::hex)).value_or("bad"));
-    BOOST_ASSERT("377" == boost::convert<std::string>::from(255, cnv(arg::base = cnv::base::oct)).value_or("bad"));
+    BOOST_TEST("255" == boost::convert<std::string>::from(255, cnv(arg::base = cnv::base::dec)).value_or("bad"));
+    BOOST_TEST( "ff" == boost::convert<std::string>::from(255, cnv(arg::base = cnv::base::hex)).value_or("bad"));
+    BOOST_TEST("377" == boost::convert<std::string>::from(255, cnv(arg::base = cnv::base::oct)).value_or("bad"));
 }
 
 template<typename Converter>
 void
 test::string_to_type(Converter const& cnv)
 {
-    BOOST_ASSERT( 255 == boost::convert<int>::from("255", cnv(arg::base = cnv::base::dec)).value_or(999));
-    BOOST_ASSERT( 999 == boost::convert<int>::from( "FF", cnv(arg::base = cnv::base::dec)).value_or(999));
-    BOOST_ASSERT( 255 == boost::convert<int>::from( "FF", cnv(arg::base = cnv::base::hex)).value_or(999));
-    BOOST_ASSERT( 173 == boost::convert<int>::from("255", cnv(arg::base = cnv::base::oct)).value_or(999));
-    BOOST_ASSERT( 999 != boost::convert<double>::from("1.23", cnv).value_or(999));
-}
-
-template<typename Type>
-bool
-assign(Type& value_out, Type const& value_in)
-{
-    value_out = value_in;
-    return true;
+    BOOST_TEST( 255 == boost::convert<int>::from("255", cnv(arg::base = cnv::base::dec)).value_or(999));
+    BOOST_TEST( 999 == boost::convert<int>::from( "FF", cnv(arg::base = cnv::base::dec)).value_or(999));
+    BOOST_TEST( 255 == boost::convert<int>::from( "FF", cnv(arg::base = cnv::base::hex)).value_or(999));
+    BOOST_TEST( 173 == boost::convert<int>::from("255", cnv(arg::base = cnv::base::oct)).value_or(999));
+    BOOST_TEST( 999 != boost::convert<double>::from("1.23", cnv).value_or(999));
 }
 
 int
@@ -52,7 +45,8 @@ main(int argc, char const* argv[])
 	test::type_to_string(boost::printf_converter());
 	test::algorithms();
 	test::performance();
-	test::encryption();
+    test::encryption();
+    test::callables();
 
     string const           not_int_str = "not an int";
     string const               std_str = "-11";
@@ -68,14 +62,6 @@ main(int argc, char const* argv[])
     boost::cstringstream_converter ccnv; // stringstream-based char converter
 	boost::wstringstream_converter wcnv; // stringstream-based wchar_t converter
 		
-    ////////////////////////////////////////////////////////////////////////////
-    // Testing crazy in-place converter.
-    ////////////////////////////////////////////////////////////////////////////
-
-    int lc99 = convert<int>::from(c_str, boost::bind(assign<int>, _2, boost::bind(boost::lexical_cast<int, std::string>, _1))).value_or(-1);
-
-    BOOST_ASSERT(lc99 == -12);
-
     ////////////////////////////////////////////////////////////////////////////
     // Testing lexical_cast-based converter.
     ////////////////////////////////////////////////////////////////////////////
@@ -84,9 +70,9 @@ main(int argc, char const* argv[])
     int lc01 = convert<int>::from(std_str,     lcnv).value_or(-1);
     int lc02 = convert<int>::from(c_str,       lcnv).value_or(-1);
 
-    BOOST_ASSERT(lc00 ==  -1); // Failed conversion. No throw
-    BOOST_ASSERT(lc01 == -11);
-    BOOST_ASSERT(lc02 == -12);
+    BOOST_TEST(lc00 ==  -1); // Failed conversion. No throw
+    BOOST_TEST(lc01 == -11);
+    BOOST_TEST(lc02 == -12);
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing various kinds of string containers.
@@ -102,12 +88,12 @@ main(int argc, char const* argv[])
     int a004 = convert<int>::from(wc_str,      wcnv).value_or(-1);
     int a005 = convert<int>::from(array_str,   ccnv).value_or(-1);
 
-    BOOST_ASSERT(a000 ==  -1); // Failed conversion
-    BOOST_ASSERT(a001 == -11);
-    BOOST_ASSERT(a002 == -12);
-    BOOST_ASSERT(a003 == -13);
-    BOOST_ASSERT(a004 == -14);
-    BOOST_ASSERT(a005 == -15);
+    BOOST_TEST(a000 ==  -1); // Failed conversion
+    BOOST_TEST(a001 == -11);
+    BOOST_TEST(a002 == -12);
+    BOOST_TEST(a003 == -13);
+    BOOST_TEST(a004 == -14);
+    BOOST_TEST(a005 == -15);
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing with the fallback value value provided.
@@ -123,12 +109,12 @@ main(int argc, char const* argv[])
     convert<int>::result r004 = convert<int>::from(wc_str,      wcnv);
     convert<int>::result r005 = convert<int>::from(array_str,   ccnv);
 
-    BOOST_ASSERT(!r000); // Failed conversion
-    BOOST_ASSERT( r001 && r001.value() == -11);
-    BOOST_ASSERT( r002 && r002.value() == -12);
-    BOOST_ASSERT( r003 && r003.value() == -13);
-    BOOST_ASSERT( r004 && r004.value() == -14);
-    BOOST_ASSERT( r005 && r005.value() == -15);
+    BOOST_TEST(!r000); // Failed conversion
+    BOOST_TEST( r001 && r001.value() == -11);
+    BOOST_TEST( r002 && r002.value() == -12);
+    BOOST_TEST( r003 && r003.value() == -13);
+    BOOST_TEST( r004 && r004.value() == -14);
+    BOOST_TEST( r005 && r005.value() == -15);
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing without a fallback value provided.
@@ -139,7 +125,7 @@ main(int argc, char const* argv[])
     try
     {
         convert<int>::from(not_int_str, ccnv).value();
-        BOOST_ASSERT(!"failed to throw");
+        BOOST_TEST(!"failed to throw");
     }
     catch (std::exception&)
     {
@@ -151,11 +137,11 @@ main(int argc, char const* argv[])
     int a024 = convert<int>::from(wc_str,    wcnv).value();
     int a025 = convert<int>::from(array_str, ccnv).value();
 
-    BOOST_ASSERT(a021 == -11);
-    BOOST_ASSERT(a022 == -12);
-    BOOST_ASSERT(a023 == -13);
-    BOOST_ASSERT(a024 == -14);
-    BOOST_ASSERT(a025 == -15);
+    BOOST_TEST(a021 == -11);
+    BOOST_TEST(a022 == -12);
+    BOOST_TEST(a023 == -13);
+    BOOST_TEST(a024 == -14);
+    BOOST_TEST(a025 == -15);
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing convert<>::result interface.
@@ -171,17 +157,17 @@ main(int argc, char const* argv[])
     convert<int>::result r014 = convert<int>::from(wc_str, wcnv);
     convert<int>::result r015 = convert<int>::from(array_str, ccnv);
 
-    BOOST_ASSERT(!r010); // Failed conversion
-    BOOST_ASSERT( r011 && r011.value() == -11);
-    BOOST_ASSERT( r012 && r012.value() == -12);
-    BOOST_ASSERT( r013 && r013.value() == -13);
-    BOOST_ASSERT( r014 && r014.value() == -14);
-    BOOST_ASSERT( r015 && r015.value() == -15);
+    BOOST_TEST(!r010); // Failed conversion
+    BOOST_TEST( r011 && r011.value() == -11);
+    BOOST_TEST( r012 && r012.value() == -12);
+    BOOST_TEST( r013 && r013.value() == -13);
+    BOOST_TEST( r014 && r014.value() == -14);
+    BOOST_TEST( r015 && r015.value() == -15);
 
     try
     {
         r010.value(); // Throws on an attempt to retrieve the value.
-        BOOST_ASSERT(!"failed to throw");
+        BOOST_TEST(!"failed to throw");
     }
     catch (std::exception&)
     {
@@ -203,11 +189,11 @@ main(int argc, char const* argv[])
     convert<wstring>::result rs004 = convert<wstring>::from(-5, wcnv);
     convert< string>::result rs005 = convert< string>::from(-5, ccnv);
 
-    BOOST_ASSERT(s001 ==  "-5"); BOOST_ASSERT(rs001 && rs001.value() ==  "-5");
-    BOOST_ASSERT(s002 ==  "-5"); BOOST_ASSERT(rs002 && rs002.value() ==  "-5");
-    BOOST_ASSERT(s003 == L"-5"); BOOST_ASSERT(rs003 && rs003.value() == L"-5");
-    BOOST_ASSERT(s004 == L"-5"); BOOST_ASSERT(rs004 && rs004.value() == L"-5");
-    BOOST_ASSERT(s005 ==  "-5"); BOOST_ASSERT(rs005 && rs005.value() ==  "-5");
+    BOOST_TEST(s001 ==  "-5"); BOOST_TEST(rs001 && rs001.value() ==  "-5");
+    BOOST_TEST(s002 ==  "-5"); BOOST_TEST(rs002 && rs002.value() ==  "-5");
+    BOOST_TEST(s003 == L"-5"); BOOST_TEST(rs003 && rs003.value() == L"-5");
+    BOOST_TEST(s004 == L"-5"); BOOST_TEST(rs004 && rs004.value() == L"-5");
+    BOOST_TEST(s005 ==  "-5"); BOOST_TEST(rs005 && rs005.value() ==  "-5");
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing int-to-string conversion with no fallback value.
@@ -218,10 +204,10 @@ main(int argc, char const* argv[])
     convert< string>::result rs010 = convert< string>::from(-5, ccnv);
     convert<wstring>::result rs011 = convert<wstring>::from(-5, wcnv);
 
-    BOOST_ASSERT( s010 ==  "-5");
-    BOOST_ASSERT( s011 == L"-5");
-    BOOST_ASSERT(rs010 && rs010.value() ==  "-5");
-    BOOST_ASSERT(rs011 && rs011.value() == L"-5");
+    BOOST_TEST( s010 ==  "-5");
+    BOOST_TEST( s011 == L"-5");
+    BOOST_TEST(rs010 && rs010.value() ==  "-5");
+    BOOST_TEST(rs011 && rs011.value() == L"-5");
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing conversions of a user-defined type
@@ -240,16 +226,16 @@ main(int argc, char const* argv[])
     direction                  dn_dir4 = convert<direction>::from("junk", ccnv).value_or(direction::dn);
     convert<direction>::result up_dir4 = convert<direction>::from("junk", ccnv);
 
-    BOOST_ASSERT(up_dir0_str == "up");
-    BOOST_ASSERT(dn_dir0_str == "dn");
-    BOOST_ASSERT(up_dir1_str == "up");
-    BOOST_ASSERT(dn_dir1_str == "dn");
-    BOOST_ASSERT(up_dir2 == up_dir1);
-    BOOST_ASSERT(dn_dir2 == dn_dir1);
-    BOOST_ASSERT(up_dir3 == direction::up);
-    BOOST_ASSERT(dn_dir3 == direction::dn);
-    BOOST_ASSERT(dn_dir4 == direction::dn);
-    BOOST_ASSERT(!up_dir4); // Failed conversion
+    BOOST_TEST(up_dir0_str == "up");
+    BOOST_TEST(dn_dir0_str == "dn");
+    BOOST_TEST(up_dir1_str == "up");
+    BOOST_TEST(dn_dir1_str == "dn");
+    BOOST_TEST(up_dir2 == up_dir1);
+    BOOST_TEST(dn_dir2 == dn_dir1);
+    BOOST_TEST(up_dir3 == direction::up);
+    BOOST_TEST(dn_dir3 == direction::dn);
+    BOOST_TEST(dn_dir4 == direction::dn);
+    BOOST_TEST(!up_dir4); // Failed conversion
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing formatters/manipulators
@@ -258,7 +244,7 @@ main(int argc, char const* argv[])
     try
     {
         boost::lexical_cast<int>("FF");
-        BOOST_ASSERT(!"We should not be here");
+        BOOST_TEST(!"We should not be here");
     }
     catch (...)
     {
@@ -269,15 +255,15 @@ main(int argc, char const* argv[])
     int hex_v03 = convert<int>::from("FF", ccnv(std::dec)).value_or(-5);
     int hex_v04 = convert<int>::from(L"F", wcnv(std::dec)).value_or(-5);
 
-    BOOST_ASSERT(hex_v01 == 255); // "FF"
-    BOOST_ASSERT(hex_v02 ==  15); // L"F"
-    BOOST_ASSERT(hex_v03 ==  -5);
-    BOOST_ASSERT(hex_v04 ==  -5);
+    BOOST_TEST(hex_v01 == 255); // "FF"
+    BOOST_TEST(hex_v02 ==  15); // L"F"
+    BOOST_TEST(hex_v03 ==  -5);
+    BOOST_TEST(hex_v04 ==  -5);
 
     ccnv(std::showbase)(std::uppercase)(std::hex);
 
-    BOOST_ASSERT(convert<string>::from(255, ccnv).value() == "0XFF");
-    BOOST_ASSERT(convert<string>::from( 15, ccnv).value() ==  "0XF");
+    BOOST_TEST(convert<string>::from(255, ccnv).value() == "0XFF");
+    BOOST_TEST(convert<string>::from( 15, ccnv).value() ==  "0XF");
 
     char const*  double_s01 = test::is_msc ? "1.2345E-002"
                             : test::is_gcc ? "1.2345E-02"
@@ -290,7 +276,7 @@ main(int argc, char const* argv[])
     double double_v01 = convert<double>::from(double_s01, ccnv).value();
     string double_s02 = convert<string>::from(double_v01, ccnv).value();
 
-    BOOST_ASSERT(double_s01 == double_s02);
+    BOOST_TEST(double_s01 == double_s02);
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing locale
@@ -323,8 +309,8 @@ main(int argc, char const* argv[])
     printf("rus locale=%s, presentation=%s.\n", rus_locale.name().c_str(), double_rus.c_str());
     printf("eng locale=%s, presentation=%s.\n", eng_locale.name().c_str(), double_eng.c_str());
 
-    BOOST_ASSERT(double_rus == rus_expected);
-    BOOST_ASSERT(double_eng == eng_expected);
+    BOOST_TEST(double_rus == rus_expected);
+    BOOST_TEST(double_eng == eng_expected);
 
     ////////////////////////////////////////////////////////////////////////////
     // Testing string-to-bool and bool-to-string conversions
@@ -338,24 +324,23 @@ main(int argc, char const* argv[])
 //    convert<bool>::result bool_res6 = convert<bool>::from(L"yes",  false, wcnv);
 //    convert<bool>::result bool_res7 = convert<bool>::from("junk",   true, ccnv);
 //
-//    BOOST_ASSERT( bool_res1 && bool_res1.value() == true);
-//    BOOST_ASSERT( bool_res2 && bool_res2.value() == true);
-//    BOOST_ASSERT( bool_res3 && bool_res3.value() == true);
-//    BOOST_ASSERT( bool_res4 && bool_res4.value() == true);
-//    BOOST_ASSERT( bool_res5 && bool_res5.value() == true);
-//    BOOST_ASSERT( bool_res6 && bool_res6.value() == true);
-//    BOOST_ASSERT(!bool_res7 && bool_res7.value() == true);
+//    BOOST_TEST( bool_res1 && bool_res1.value() == true);
+//    BOOST_TEST( bool_res2 && bool_res2.value() == true);
+//    BOOST_TEST( bool_res3 && bool_res3.value() == true);
+//    BOOST_TEST( bool_res4 && bool_res4.value() == true);
+//    BOOST_TEST( bool_res5 && bool_res5.value() == true);
+//    BOOST_TEST( bool_res6 && bool_res6.value() == true);
+//    BOOST_TEST(!bool_res7 && bool_res7.value() == true);
 //
 //    string bool_str1 = convert<string>::from(true,  ccnv).value_or("failed");
 //    string bool_str2 = convert<string>::from(false, ccnv).value_or("failed");
 //    string bool_str3 = convert<string>::from(1,     ccnv).value_or("failed");
 //    string bool_str4 = convert<string>::from(0,     ccnv).value_or("failed");
 //
-//    BOOST_ASSERT(bool_str1 == "1");
-//    BOOST_ASSERT(bool_str2 == "0");
-//    BOOST_ASSERT(bool_str3 == "1");
-//    BOOST_ASSERT(bool_str4 == "0");
+//    BOOST_TEST(bool_str1 == "1");
+//    BOOST_TEST(bool_str2 == "0");
+//    BOOST_TEST(bool_str3 == "1");
+//    BOOST_TEST(bool_str4 == "0");
 
-    printf("Test completed successfully.\n");
-    return 0;
+    return boost::report_errors();
 }