Merge link fix.

[SVN r59013]

doc/changes.qbk

@@ -90,4 +90,10 @@
   instead of trying to configure every possibility manually.
 * Workaround for when STLport doesn't support long double.
 
+[h2 Boost 1.42.0]
+
+* Reduce the number of warnings for Visual C++ warning level 4.
+* Some code formatting changes to fit lines into 80 characters.
+* Rename an internal namespace.
+
 [endsect]

doc/tutorial.qbk

@@ -110,7 +110,7 @@ And you can now use [classref boost::hash] with book:
     assert(books.find(dandelion) == books.end());
 
 The full example can be found in:
-[@boost:/libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.hpp]
+[@boost:/libs/functional/hash/examples/books.hpp /libs/functional/hash/examples/books.hpp]
 and
 [@boost:/libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.cpp].
 

examples/books.cpp

@@ -20,6 +20,7 @@ int main()
 
     boost::hash<library::book> book_hasher;
     std::size_t knife_hash_value = book_hasher(knife);
+    (void)knife_hash_value; // suppress unused variable warning
 
     // If std::unordered_set was available:
     //

include/boost/functional/hash/detail/float_functions.hpp

@@ -84,7 +84,7 @@ namespace boost {
 // the boost namespace they'll always be preferable to any other function
 // (since the arguments are built in types, ADL can't be used).
 
-namespace BOOST_HASH_DETECT_FLOAT_FUNCTIONS {
+namespace boost_hash_detect_float_functions {
     template <class Float> boost::hash_detail::not_found ldexp(Float, int);
     template <class Float> boost::hash_detail::not_found frexp(Float, int*);    
 }
@@ -103,7 +103,7 @@ namespace BOOST_HASH_DETECT_FLOAT_FUNCTIONS {
 // happen mainly when there's a template in the same namesapce.
 
 #define BOOST_HASH_CALL_FLOAT_FUNC(cpp_func, c99_func, type1, type2)    \
-namespace BOOST_HASH_DETECT_FLOAT_FUNCTIONS {                           \
+namespace boost_hash_detect_float_functions {                           \
     template <class Float>                                              \
     boost::hash_detail::not_found c99_func(Float, type2);               \
 }                                                                       \
@@ -112,7 +112,7 @@ namespace boost {                                                       \
     namespace hash_detail {                                             \
         namespace c99_func##_detect {                                   \
             using namespace std;                                        \
-            using namespace BOOST_HASH_DETECT_FLOAT_FUNCTIONS;          \
+            using namespace boost_hash_detect_float_functions;          \
                                                                         \
             struct check {                                              \
                 static type1 x;                                         \

include/boost/functional/hash/hash.hpp

@@ -20,7 +20,8 @@
 #include <boost/type_traits/is_pointer.hpp>
 #endif
 
-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#if BOOST_WORKAROUND(__GNUC__, < 3) \
+    && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 #define BOOST_HASH_CHAR_TRAITS string_char_traits
 #else
 #define BOOST_HASH_CHAR_TRAITS char_traits
@@ -67,7 +68,8 @@ namespace boost
     std::size_t hash_value(long double v);
 
     template <class Ch, class A>
-    std::size_t hash_value(std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
+    std::size_t hash_value(
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
 
     // Implementation
 
@@ -197,6 +199,16 @@ namespace boost
         return x + (x >> 3);
     }
 
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC <= 1400
+#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to
+                              // 'unsigned int', possible loss of data
+                              // A misguided attempt to detect 64-bit
+                              // incompatability.
+#endif
+#endif
+
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
     template <class T>
     inline void hash_combine(std::size_t& seed, T& v)
@@ -209,6 +221,10 @@ namespace boost
         seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
     }
 
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
     template <class It>
     inline std::size_t hash_range(It first, It last)
     {
@@ -272,7 +288,8 @@ namespace boost
 #endif
 
     template <class Ch, class A>
-    inline std::size_t hash_value(std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
+    inline std::size_t hash_value(
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
     {
         return hash_range(v.begin(), v.end());
     }
@@ -297,8 +314,8 @@ namespace boost
     //
     
     // Define the specializations required by the standard. The general purpose
-    // boost::hash is defined later in extensions.hpp if BOOST_HASH_NO_EXTENSIONS
-    // is not defined.
+    // boost::hash is defined later in extensions.hpp if
+    // BOOST_HASH_NO_EXTENSIONS is not defined.
     
     // BOOST_HASH_SPECIALIZE - define a specialization for a type which is
     // passed by copy.

test/Jamfile.v2

@@ -7,9 +7,14 @@ import testing ;
 
 project hash-tests
     : requirements
-        <toolset>gcc:<define>_GLIBCXX_DEBUG
-        <toolset>gcc:<cxxflags>-Wsign-promo
-        #<toolset>gcc:<cxxflags>-Wextra
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>intel:<cxxflags>-strict-ansi
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>msvc:<warnings-as-errors>on
+        #<toolset>gcc:<warnings-as-errors>on
+        #<toolset>darwin:<warnings-as-errors>on
     ;
 
 test-suite functional/hash
@@ -38,6 +43,10 @@ test-suite functional/hash
         [ run link_ext_test.cpp link_no_ext_test.cpp ]
         [ run extensions_hpp_test.cpp ]
         [ run container_fwd_test.cpp ]
+        [ run container_fwd_test.cpp : :
+            :   <toolset>gcc:<define>_GLIBCXX_DEBUG
+                <toolset>darwin:<define>_GLIBCXX_DEBUG
+            :   container_fwd_gcc_debug ]
         [ compile-fail hash_no_ext_fail_test.cpp ]
         [ compile-fail namespace_fail_test.cpp ]
         [ run hash_no_ext_macro_1.cpp ]

test/config.hpp

@@ -12,3 +12,10 @@
 #    define TEST_EXTENSIONS
 #  endif
 #endif
+
+#if defined(_WIN32_WCE)
+// The standard windows mobile headers trigger this warning so I disable it
+// before doing anything else.
+#pragma warning(disable:4201)   // nonstandard extension used :
+                                // nameless struct/union
+#endif

test/container_fwd_test.cpp

@@ -3,16 +3,21 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/functional/detail/container_fwd.hpp>
 
-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#if BOOST_WORKAROUND(__GNUC__, < 3) && \
+    !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 template <class charT, class Allocator>
-static void test(std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
+static void test(
+    std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
 {
 }
 #else
 template <class charT, class Allocator>
-static void test(std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
+static void test(
+    std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
 {
 }
 #endif

test/extensions_hpp_test.cpp

@@ -8,6 +8,8 @@
 // It probably should be in boost/functional/hash/detail, but since it isn't it
 // should work.
 
+#include "./config.hpp"
+
 #include <boost/functional/hash/extensions.hpp>
 
 int main() {

test/hash_complex_test.cpp

@@ -19,20 +19,26 @@ int main() {}
 
 #include <boost/detail/lightweight_test.hpp>
 
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4244)   // conversion from 'unsigned long' to
+                                // 'unsigned short', possible loss of data
+#pragma warning(disable:4245)   // conversion from 'int' to
+                                // 'const unsigned short',
+                                // signed/unsigned mismatch
+#pragma warning(disable:4305)   // truncation from 'double' to
+                                // 'const std::complex<float>::_Ty'
+#pragma warning(disable:4309)   // truncation of constant value
+#pragma warning(disable:4512)   // assignment operator could not be generated
+#if BOOST_MSVC < 1400
+#pragma warning(disable:4267)   // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data
+#endif
+#endif
+
 #include <complex>
 #include <sstream>
 #include <boost/limits.hpp>
 
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4244) // conversion from 'unsigned long' to 'unsigned short', possible loss of data
-#pragma warning(disable:4512) // assignment operator could not be generated
-#endif
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
 template <class T>
 void generic_complex_tests(std::complex<T> v)
 {
@@ -80,13 +86,17 @@ void complex_integral_tests(Integer*)
 
 int main()
 {
+    // I've comments out the short and unsigned short tests
+    // as they cause warnings and don't really test
+    // anything that the other tests already deal with.
+
     complex_float_tests((float*) 0);
     complex_float_tests((double*) 0);
     complex_float_tests((long double*) 0);
-    complex_integral_tests((short*) 0);
+    //complex_integral_tests((short*) 0);
     complex_integral_tests((int*) 0);
     complex_integral_tests((long*) 0);
-    complex_integral_tests((unsigned short*) 0);
+    //complex_integral_tests((unsigned short*) 0);
     complex_integral_tests((unsigned int*) 0);
     complex_integral_tests((unsigned long*) 0);
 

test/hash_custom_test.cpp

@@ -3,6 +3,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
 #include <boost/config.hpp>
 #include <cstddef>
 
@@ -83,8 +84,8 @@ void custom_tests()
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed ==
-            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
+        custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 

test/hash_float_test.hpp

@@ -22,7 +22,12 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable:4127)   // conditional expression is constant
+#pragma warning(disable:4723)   // conditional expression is constant
+#if BOOST_MSVC < 1400
+#pragma warning(disable:4267)   // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data
+#endif
 #endif
 
 char const* float_type(float*) { return "float"; }
@@ -32,23 +37,33 @@ char const* float_type(long double*) { return "long double"; }
 template <class T>
 void float_tests(char const* name, T* = 0)
 {
-    std::cerr<<"\n"
-        <<"Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"<<name<<">\n"
-        <<"\n"
-        <<"boost::hash_detail::limits<T>::digits = "
-            <<boost::hash_detail::limits<T>::digits<<"\n"
-        <<"boost::hash_detail::limits<int>::digits = "
-            <<boost::hash_detail::limits<int>::digits<<"\n"
-        <<"boost::hash_detail::limits<std::size_t>::digits = "
-            <<boost::hash_detail::limits<std::size_t>::digits<<"\n"
-        <<"\n"
-        <<"boost::hash_detail::call_ldexp<T>::float_type = "
-            <<float_type((BOOST_DEDUCED_TYPENAME boost::hash_detail::call_ldexp<T>::float_type*)0)<<"\n"
-        <<"boost::hash_detail::call_frexp<T>::float_type = "
-            <<float_type((BOOST_DEDUCED_TYPENAME boost::hash_detail::call_frexp<T>::float_type*)0)<<"\n"
-        <<"boost::hash_detail::select_hash_type<T>::type = "
-            <<float_type((BOOST_DEDUCED_TYPENAME boost::hash_detail::select_hash_type<T>::type*)0)<<"\n"
-        <<"\n"
+    std::cerr
+        <<  "\n"
+        <<  "Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"
+        <<  name
+        <<  ">\n"
+        <<  "\n"
+        <<  "boost::hash_detail::limits<T>::digits = "
+        <<  boost::hash_detail::limits<T>::digits<< "\n"
+        <<  "boost::hash_detail::limits<int>::digits = "
+        <<  boost::hash_detail::limits<int>::digits<< "\n"
+        <<  "boost::hash_detail::limits<std::size_t>::digits = "
+        <<  boost::hash_detail::limits<std::size_t>::digits
+        <<  "\n"
+        <<  "\n"
+        <<  "boost::hash_detail::call_ldexp<T>::float_type = "
+        <<  float_type(static_cast<BOOST_DEDUCED_TYPENAME
+                boost::hash_detail::call_ldexp<T>::float_type*>(0))
+        <<  "\n"
+        <<  "boost::hash_detail::call_frexp<T>::float_type = "
+        <<  float_type(static_cast<BOOST_DEDUCED_TYPENAME
+                boost::hash_detail::call_frexp<T>::float_type*>(0))
+        <<  "\n"
+        <<  "boost::hash_detail::select_hash_type<T>::type = "
+        <<  float_type(static_cast<BOOST_DEDUCED_TYPENAME
+                boost::hash_detail::select_hash_type<T>::type*>(0))
+        <<  "\n"
+        <<  "\n"
         ;
 
     HASH_NAMESPACE::hash<T> x1;
@@ -68,7 +83,9 @@ void float_tests(char const* name, T* = 0)
 
 // Doing anything with infinity causes borland to crash.
 #if defined(__BORLANDC__)
-    std::cerr<<"Not running infinity checks on Borland, as it causes it to crash.\n";
+    std::cerr
+        <<  "Not running infinity checks on Borland, as it causes it to crash."
+            "\n";
 #else
     if(boost::hash_detail::limits<T>::has_infinity) {
         T infinity = -log(zero);
@@ -107,19 +124,40 @@ void float_tests(char const* name, T* = 0)
         // This should really be 'has_denorm == denorm_present' but some
         // compilers don't have 'denorm_present'. See also a later use.
         if(boost::hash_detail::limits<T>::has_denorm) {
-            if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(infinity)) {
-                std::cerr<<"x1(denorm_min) == x1(infinity) == "<<x1(infinity)<<"\n";
+            if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(infinity))
+            {
+                std::cerr
+                    <<  "x1(denorm_min) == x1(infinity) == "
+                    <<  x1(infinity)
+                    <<  "\n";
             }
-            if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(minus_infinity)) {
-                std::cerr<<"x1(denorm_min) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+
+            if(x1(boost::hash_detail::limits<T>::denorm_min()) ==
+                x1(minus_infinity))
+            {
+                std::cerr
+                    <<  "x1(denorm_min) == x1(-infinity) == "
+                    <<  x1(minus_infinity)
+                    <<  "\n";
             }
         }
+
         if(boost::hash_detail::limits<T>::has_quiet_NaN) {
-            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(infinity)) {
-                std::cerr<<"x1(quiet_NaN) == x1(infinity) == "<<x1(infinity)<<"\n";
+            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(infinity))
+            {
+                std::cerr
+                    <<  "x1(quiet_NaN) == x1(infinity) == "
+                    <<  x1(infinity)
+                    <<  "\n";
             }
-            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(minus_infinity)) {
-                std::cerr<<"x1(quiet_NaN) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+
+            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
+                x1(minus_infinity))
+            {
+                std::cerr
+                    <<  "x1(quiet_NaN) == x1(-infinity) == "
+                    <<  x1(minus_infinity)
+                    <<  "\n";
             }
         }
     }
@@ -142,10 +180,12 @@ void float_tests(char const* name, T* = 0)
     BOOST_TEST(x1(max) == HASH_NAMESPACE::hash_value(max));
     BOOST_TEST(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
     BOOST_TEST(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
-    BOOST_TEST(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
+    BOOST_TEST(x1(three_quarter_max) ==
+        HASH_NAMESPACE::hash_value(three_quarter_max));
 #endif
 
-    // The '!=' tests could legitimately fail, but with my hash it indicates a bug.
+    // The '!=' tests could legitimately fail, but with my hash it indicates a
+    // bug.
     BOOST_TEST(x1(max) == x1(max));
     BOOST_TEST(x1(max) != x1(quarter_max));
     BOOST_TEST(x1(max) != x1(half_max));
@@ -175,7 +215,8 @@ void float_tests(char const* name, T* = 0)
 
 #if defined(TEST_EXTENSIONS)
     BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) ==
-            HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::epsilon()));
+            HASH_NAMESPACE::hash_value(
+                boost::hash_detail::limits<T>::epsilon()));
 #endif
 
     BOOST_TEST(boost::hash_detail::limits<T>::epsilon() != (T) 0);
@@ -212,14 +253,19 @@ void float_tests(char const* name, T* = 0)
         // specialization of boost::hash_detail::limits::denorm_min() for long
         // doubles which causes this test to fail.
         if(x1(boost::hash_detail::limits<T>::denorm_min()) !=
-            HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::denorm_min()))
+            HASH_NAMESPACE::hash_value(
+                boost::hash_detail::limits<T>::denorm_min()))
         {
-            std::cerr<<"x1(boost::hash_detail::limits<T>::denorm_min()) = "
-                << x1(boost::hash_detail::limits<T>::denorm_min())
-                << "\nhash_value(boost::hash_detail::limits<T>::denorm_min()) = "
-                << HASH_NAMESPACE::hash_value(
+            std::cerr
+                <<  "x1(boost::hash_detail::limits<T>::denorm_min()) = "
+                <<  x1(boost::hash_detail::limits<T>::denorm_min())
+                <<  "\nhash_value(boost::hash_detail::limits<T>::denorm_min())"
+                    " = "
+                <<  HASH_NAMESPACE::hash_value(
                         boost::hash_detail::limits<T>::denorm_min())
-                << "\nx1(0) = "<<x1(0)<<"\n";
+                <<  "\nx1(0) = "
+                <<  x1(0)
+                <<  "\n";
         }
 #endif
     }
@@ -231,7 +277,8 @@ void float_tests(char const* name, T* = 0)
             std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
         }
         BOOST_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
-            HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::quiet_NaN()));
+            HASH_NAMESPACE::hash_value(
+                boost::hash_detail::limits<T>::quiet_NaN()));
     }
 #endif
 }

test/hash_friend_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/config.hpp>
 #include <cstddef>
 
@@ -85,8 +87,8 @@ void custom_tests()
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed ==
-            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
+        custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 

test/hash_fwd_test.hpp

@@ -60,7 +60,8 @@ namespace test {
     template <class T>
     std::size_t hash_value(test_type3<T> const& x)
     {
-        std::size_t seed = HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
+        std::size_t seed =
+            HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
         HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
         return seed;
     }
@@ -91,7 +92,8 @@ namespace boost
     template <class T>
     std::size_t hash_value(test::test_type3<T> const& x)
     {
-        std::size_t seed = HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
+        std::size_t seed =
+            HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
         HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
         return seed;
     }

test/hash_fwd_test_1.cpp

@@ -5,6 +5,8 @@
 
 // This checks that template code implemented using hash_fwd will work.
 
+#include "./config.hpp"
+
 #include "./hash_fwd_test.hpp"
 
 #include <boost/detail/lightweight_test.hpp>
@@ -66,10 +68,12 @@ void fwd_test3()
     test::test_type3<int> x(values1.begin(), values1.end());
     test::test_type3<std::string> y(values2.begin(), values2.end());
 
-    std::size_t seed1 = HASH_NAMESPACE::hash_range(values1.begin(), values1.end());
+    std::size_t seed1 =
+        HASH_NAMESPACE::hash_range(values1.begin(), values1.end());
     HASH_NAMESPACE::hash_range(seed1, values1.begin(), values1.end());
 
-    std::size_t seed2 = HASH_NAMESPACE::hash_range(values2.begin(), values2.end());
+    std::size_t seed2 =
+        HASH_NAMESPACE::hash_range(values2.begin(), values2.end());
     HASH_NAMESPACE::hash_range(seed2, values2.begin(), values2.end());
 
     HASH_NAMESPACE::hash<test::test_type3<int> > hasher_test_int;
@@ -90,4 +94,3 @@ int main()
 #endif
     return boost::report_errors();
 }
-

test/hash_fwd_test_2.cpp

@@ -6,6 +6,8 @@
 // This test just makes sure a header which uses hash_fwd can compile without
 // the main hash headers.
 
+#include "./config.hpp"
+
 #if !defined(TEST_EXTENSIONS) || defined(TEST_STD_INCLUDES)
 
 int main() {}

test/hash_global_namespace_test.cpp

@@ -6,6 +6,8 @@
 // This test demonstrates an ADL bug in Borland 5.5 where ADL isn't performed
 // in the global namespace.
 
+#include "./config.hpp"
+
 #include <boost/config.hpp>
 #include <cstddef>
 
@@ -83,8 +85,8 @@ void custom_tests()
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed ==
-            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
+        custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 

test/hash_map_test.hpp

@@ -11,6 +11,7 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
+#pragma warning(disable:4244) // conversion from 'int' to 'float'
 #pragma warning(disable:4245) // signed/unsigned mismatch
 #endif
 
@@ -21,19 +22,21 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
     {
         const int number_of_containers = 10;
         T containers[number_of_containers];
-        typedef typename T::value_type pair;
+        typedef BOOST_DEDUCED_TYPENAME T::value_type pair;
+        typedef BOOST_DEDUCED_TYPENAME T::key_type key;
+        typedef BOOST_DEDUCED_TYPENAME T::mapped_type value;
 
         for(int i = 0; i < 5; ++i) {
             for(int j = 0; j < i; ++j)
-                containers[i].insert(pair(0, 0));
+                containers[i].insert(pair(key(0), value(0)));
         }
 
-        containers[6].insert(pair(1,0));
-        containers[7].insert(pair(1,0));
-        containers[7].insert(pair(1,0));
-        containers[8].insert(pair(-1,1));
-        containers[9].insert(pair(-1,3));
-        containers[9].insert(pair(-1,3));
+        containers[6].insert(pair(key(1),value(0)));
+        containers[7].insert(pair(key(1),value(0)));
+        containers[7].insert(pair(key(1),value(0)));
+        containers[8].insert(pair(key(-1),value(1)));
+        containers[9].insert(pair(key(-1),value(3)));
+        containers[9].insert(pair(key(-1),value(3)));
 
         HASH_NAMESPACE::hash<T> hasher;
 

test/hash_no_ext_fail_test.cpp

@@ -3,17 +3,26 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define HASH_NAMESPACE boost
+#include "./config.hpp"
 
 // Simple test to make sure BOOST_HASH_NO_EXTENSIONS does disable extensions
 // (or at least one of them).
-#define BOOST_HASH_NO_EXTENSIONS
+#if !defined(BOOST_HASH_NO_EXTENSIONS)
+#  define BOOST_HASH_NO_EXTENSIONS
+#endif
 
-#include <boost/functional/hash.hpp>
-#include <boost/functional/hash.hpp>
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash.hpp>
+#endif
+
+template <class T> void ignore(T const&) {}
 
 int main()
 {
     HASH_NAMESPACE::hash< int[10] > hasher;
+    ignore(hasher);
+
     return 0;
 }

test/hash_no_ext_macro_1.cpp

@@ -3,24 +3,27 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define HASH_NAMESPACE boost
+#include "./config.hpp"
+
+#if defined(TEST_EXTENSIONS)
 
 // Include header without BOOST_HASH_NO_EXTENSIONS defined
-#if defined(BOOST_HASH_NO_EXTENSIONS)
-#undef BOOST_HASH_NO_EXTENSIONS
-#endif
-#include <boost/functional/hash.hpp>
+#  if defined(BOOST_HASH_NO_EXTENSIONS)
+#    undef BOOST_HASH_NO_EXTENSIONS
+#  endif
+#  include <boost/functional/hash.hpp>
 
 // Include header with BOOST_HASH_NO_EXTENSIONS defined
-#define BOOST_HASH_NO_EXTENSIONS
-#include <boost/functional/hash.hpp>
+#  define BOOST_HASH_NO_EXTENSIONS
+#  include <boost/functional/hash.hpp>
+#endif
 
 #include <boost/detail/lightweight_test.hpp>
 #include <deque>
-#include <cassert>
 
 int main()
 {
+#if defined(TEST_EXTENSIONS)
     std::deque<int> x;
 
     x.push_back(1);
@@ -28,6 +31,7 @@ int main()
 
     HASH_NAMESPACE::hash<std::deque<int> > hasher;
     BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
+#endif
 
     return boost::report_errors();
 }

test/hash_no_ext_macro_2.cpp

@@ -3,23 +3,27 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define HASH_NAMESPACE boost
+#include "./config.hpp"
+
+#if defined(TEST_EXTENSIONS)
 
 // Include header with BOOST_HASH_NO_EXTENSIONS defined
-#if !defined(BOOST_HASH_NO_EXTENSIONS)
-#define BOOST_HASH_NO_EXTENSIONS
-#endif
-#include <boost/functional/hash.hpp>
+#  if !defined(BOOST_HASH_NO_EXTENSIONS)
+#    define BOOST_HASH_NO_EXTENSIONS
+#  endif
+#  include <boost/functional/hash.hpp>
 
 // Include header without BOOST_HASH_NO_EXTENSIONS defined
-#undef BOOST_HASH_NO_EXTENSIONS
-#include <boost/functional/hash.hpp>
+#  undef BOOST_HASH_NO_EXTENSIONS
+#  include <boost/functional/hash.hpp>
+#endif
 
 #include <boost/detail/lightweight_test.hpp>
 #include <map>
 
 int main()
 {
+#if defined(TEST_EXTENSIONS)
     std::map<int, int> x;
 
     x.insert(std::map<int, int>::value_type(53, -42));
@@ -27,6 +31,7 @@ int main()
 
     HASH_NAMESPACE::hash<std::map<int, int> > hasher;
     BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
+#endif
     
     return boost::report_errors();
 }

test/hash_number_test.cpp

@@ -55,8 +55,11 @@ void numeric_test(T*)
 
     if (limits::is_integer)
     {
-        if(limits::is_signed || limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
+        if(limits::is_signed ||
+            limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
+        {
             BOOST_TEST(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
+        }
         BOOST_TEST(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
         BOOST_TEST(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
         BOOST_TEST(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));

test/hash_range_test.cpp

@@ -70,10 +70,12 @@ void hash_range_tests()
     BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    std::size_t seed = HASH_NAMESPACE::hash_range(values3.begin(), values3.end());
+    std::size_t seed =
+        HASH_NAMESPACE::hash_range(values3.begin(), values3.end());
     HASH_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
     HASH_NAMESPACE::hash_range(seed, x.begin(), x.end());
-    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
+    BOOST_TEST(seed ==
+        HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
 }
 
 int main()

test/link_ext_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #define HASH_NAMESPACE boost
 #include <boost/functional/hash.hpp>
 #include <boost/detail/lightweight_test.hpp>

test/link_no_ext_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #define HASH_NAMESPACE boost
 #define BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>

test/link_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/functional/hash.hpp>
 
 extern int f();

test/link_test_2.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/functional/hash.hpp>
 
 int f() { return 0; }

test/namespace_fail_test.cpp

@@ -6,6 +6,8 @@
 // Check that I haven't inadvertantly pulled namespace std into the global
 // namespace.
 
+#include "./config.hpp"
+
 #include <list>
 #include <boost/functional/hash.hpp>