Hash: Merge C++11 forward declaration fix.

[SVN r80054]

doc/changes.qbk

@@ -3,8 +3,6 @@
  / 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) ]
 
-[template ticket[number]'''<ulink url="https://svn.boost.org/trac/boost/ticket/'''[number]'''">'''#[number]'''</ulink>''']
-
 [section:changes Change Log]
 
 [h2 Boost 1.33.0]
@@ -134,39 +132,4 @@
 * Add deprecation warning to the long deprecated
   `boost/functional/detail/container_fwd.hpp`.
 
-[h2 Boost 1.51.0]
-
-* Support the standard smart pointers.
-* `hash_value` now implemented using SFINAE to avoid implicit casts to built
-  in types when calling it.
-* Updated to use the new config macros.
-
-[h2 Boost 1.52.0]
-
-* Restore `enum` support, which was accidentally removed in the last version.
-* New floating point hasher - will hash the binary representation on more
-  platforms, which should be faster.
-
-[h2 Boost 1.53.0]
-
-* Add support for `boost::int128_type` and `boost::uint128_type` where
-  available - currently only `__int128` and `unsigned __int128` on some
-  versions of gcc.
-* On platforms that are known to have the standard floating point functions,
-  don't use automatic detection - which can break if there are ambiguous
-  overloads.
-* Fix undefined behaviour when using the binary float hash (Thomas Heller).
-
-[h2 Boost 1.54.0]
-
-* [@https://svn.boost.org/trac/boost/ticket/7957 Ticket 7957]:
-  Fixed a typo.
-
-[h2 Boost 1.55.0]
-
-* Simplify a SFINAE check so that it will hopefully work on Sun 5.9
-  ([ticket 8822]).
-* Suppress Visual C++ infinite loop warning ([ticket 8568]).
-
-
 [endsect]

doc/rationale.qbk

@@ -34,11 +34,11 @@ For other use cases, if you do need a higher quality hash function,
 then neither the standard hash function or `boost::hash` are appropriate.
 There are several options
 available. One is to use a second hash on the output of this hash
-function, such as [@http://web.archive.org/web/20121102023700/http://www.concentric.net/~Ttwang/tech/inthash.htm
+function, such as [@http://www.concentric.net/~ttwang/tech/inthash.htm
 Thomas Wang's hash function]. This this may not work as
 well as a hash algorithm tailored for the input.
 
-For strings there are several fast, high quality hash functions
+For strings that are several fast, high quality hash functions
 available (for example [@http://code.google.com/p/smhasher/ MurmurHash3]
 and [@http://code.google.com/p/cityhash/ Google's CityHash]),
 although they tend to be more machine specific.

include/boost/functional/detail/container_fwd.hpp

@@ -0,0 +1,27 @@
+
+// Copyright 2005-2012 Daniel James.
+// 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)
+
+// Forwarding header for container_fwd.hpp's new location.
+// This header is deprecated, I'll change the warning to an error in a future
+// release, and then later remove the header completely.
+
+#if !defined(BOOST_FUNCTIONAL_DETAIL_CONTAINER_FWD_HPP)
+#define BOOST_FUNCTIONAL_DETAIL_CONTAINER_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(__EDG__)
+#elif defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
+#pragma message("Warning: boost/functional/detail/container_fwd.hpp is deprecated, use boost/detail/container_fwd.hpp instead.")
+#elif defined(__GNUC__) || defined(__HP_aCC) || \
+    defined(__SUNPRO_CC) || defined(__IBMCPP__)
+#warning "boost/functional/detail/container_fwd.hpp is deprecated, use boost/detail/container_fwd.hpp instead."
+#endif
+
+#include <boost/detail/container_fwd.hpp>
+
+#endif

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

@@ -0,0 +1,29 @@
+
+// Copyright 2012 Daniel James.
+// 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)
+
+#if !defined(BOOST_DETAIL_CONTAINER_FWD_0X_HPP)
+#define BOOST_DETAIL_CONTAINER_FWD_0X_HPP
+
+#include <boost/detail/container_fwd.hpp>
+
+// std::array
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+#   include <array>
+#endif
+
+// std::tuple
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   include <tuple>
+#endif
+
+// std::shared_ptr/std::unique_ptr
+
+#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
+#   include <memory>
+#endif
+
+#endif

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

@@ -7,100 +7,12 @@
 #define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP
 
 #include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
 #include <boost/config/no_tr1/cmath.hpp>
 
-// Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have
-// sufficiently good floating point support to not require any
-// workarounds.
-//
-// When set to 0, the library tries to automatically
-// use the best available implementation. This normally works well, but
-// breaks when ambiguities are created by odd namespacing of the functions.
-//
-// Note that if this is set to 0, the library should still take full
-// advantage of the platform's floating point support.
-
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__LIBCOMO__)
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
-// Rogue Wave library:
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(_LIBCPP_VERSION)
-// libc++
-#   define BOOST_HASH_CONFORMANT_FLOATS 1
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-// GNU libstdc++ 3
-#   if defined(__GNUC__) && __GNUC__ >= 4
-#       define BOOST_HASH_CONFORMANT_FLOATS 1
-#   else
-#       define BOOST_HASH_CONFORMANT_FLOATS 0
-#   endif
-#elif defined(__STL_CONFIG_H)
-// generic SGI STL
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__MSL_CPP__)
-// MSL standard lib:
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__IBMCPP__)
-// VACPP std lib (probably conformant for much earlier version).
-#   if __IBMCPP__ >= 1210
-#       define BOOST_HASH_CONFORMANT_FLOATS 1
-#   else
-#       define BOOST_HASH_CONFORMANT_FLOATS 0
-#   endif
-#elif defined(MSIPL_COMPILE_H)
-// Modena C++ standard library
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
-// Dinkumware Library (this has to appear after any possible replacement libraries):
-#   if _CPPLIB_VER >= 405
-#       define BOOST_HASH_CONFORMANT_FLOATS 1
-#   else
-#       define BOOST_HASH_CONFORMANT_FLOATS 0
-#   endif
-#else
-#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
-#if BOOST_HASH_CONFORMANT_FLOATS
-
-// The standard library is known to be compliant, so don't use the
-// configuration mechanism.
-
-namespace boost {
-    namespace hash_detail {
-        template <typename Float>
-        struct call_ldexp {
-            typedef Float float_type;
-            inline Float operator()(Float x, int y) const {
-                return std::ldexp(x, y);
-            }
-        };
-
-        template <typename Float>
-        struct call_frexp {
-            typedef Float float_type;
-            inline Float operator()(Float x, int* y) const {
-                return std::frexp(x, y);
-            }
-        };
-
-        template <typename Float>
-        struct select_hash_type
-        {
-            typedef Float type;
-        };
-    }
-}
-
-#else // BOOST_HASH_CONFORMANT_FLOATS == 0
-
 // The C++ standard requires that the C float functions are overloarded
 // for float, double and long double in the std namespace, but some of the older
 // library implementations don't support this. On some that don't, the C99
@@ -331,6 +243,4 @@ namespace boost
     }
 }
 
-#endif // BOOST_HASH_CONFORMANT_FLOATS
-
 #endif

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

@@ -1,31 +1,33 @@
 
-// Copyright 2005-2012 Daniel James.
+// Copyright 2005-2009 Daniel James.
 // 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)
 
 #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER)
 #define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
+#include <boost/config.hpp>
 #include <boost/functional/hash/detail/float_functions.hpp>
 #include <boost/functional/hash/detail/limits.hpp>
-#include <boost/utility/enable_if.hpp>
 #include <boost/integer/static_log2.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <cstring>
 
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
-                              // not satisfy test. Loop body not executed
-#endif
+// Include hash implementation for the current platform.
+
+// Cygwn
+#if defined(__CYGWIN__)
+#  if defined(__i386__) || defined(_M_IX86)
+#    include <boost/functional/hash/detail/hash_float_x86.hpp>
+#  else
+#    include <boost/functional/hash/detail/hash_float_generic.hpp>
+#  endif
+#else
+#  include <boost/functional/hash/detail/hash_float_generic.hpp>
 #endif
 
 // Can we use fpclassify?
@@ -48,153 +50,6 @@
 #  define BOOST_HASH_USE_FPCLASSIFY 0
 #endif
 
-namespace boost
-{
-    namespace hash_detail
-    {
-        inline void hash_float_combine(std::size_t& seed, std::size_t value)
-        {
-            seed ^= value + (seed<<6) + (seed>>2);
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Binary hash function
-        //
-        // Only used for floats with known iec559 floats, and certain values in
-        // numeric_limits
-
-        inline std::size_t hash_binary(char* ptr, std::size_t length)
-        {
-            std::size_t seed = 0;
-
-            if (length >= sizeof(std::size_t)) {
-                seed = *(std::size_t*) ptr;
-                length -= sizeof(std::size_t);
-                ptr += sizeof(std::size_t);
-
-                while(length >= sizeof(std::size_t)) {
-                    std::size_t buffer = 0;
-                    std::memcpy(&buffer, ptr, sizeof(std::size_t));
-                    hash_float_combine(seed, buffer);
-                    length -= sizeof(std::size_t);
-                    ptr += sizeof(std::size_t);
-                }
-            }
-
-            if (length > 0) {
-                std::size_t buffer = 0;
-                std::memcpy(&buffer, ptr, length);
-                hash_float_combine(seed, buffer);
-            }
-
-            return seed;
-        }
-
-        template <typename Float, unsigned digits, unsigned max_exponent>
-        struct enable_binary_hash
-        {
-            BOOST_STATIC_CONSTANT(bool, value =
-                std::numeric_limits<Float>::is_iec559 &&
-                std::numeric_limits<Float>::digits == digits &&
-                std::numeric_limits<Float>::radix == 2 &&
-                std::numeric_limits<Float>::max_exponent == max_exponent);
-        };
-
-        template <typename Float>
-        inline std::size_t float_hash_impl(Float v,
-            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                enable_binary_hash<Float, 24, 128>::value,
-                std::size_t>::type)
-        {
-            return hash_binary((char*) &v, 4);
-        }
-
-
-        template <typename Float>
-        inline std::size_t float_hash_impl(Float v,
-            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                enable_binary_hash<Float, 53, 1024>::value,
-                std::size_t>::type)
-        {
-            return hash_binary((char*) &v, 8);
-        }
-
-        template <typename Float>
-        inline std::size_t float_hash_impl(Float v,
-            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                enable_binary_hash<Float, 64, 16384>::value,
-                std::size_t>::type)
-        {
-            return hash_binary((char*) &v, 10);
-        }
-
-        template <typename Float>
-        inline std::size_t float_hash_impl(Float v,
-            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                enable_binary_hash<Float, 113, 16384>::value,
-                std::size_t>::type)
-        {
-            return hash_binary((char*) &v, 16);
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Portable hash function
-        //
-        // Used as a fallback when the binary hash function isn't supported.
-
-        template <class T>
-        inline std::size_t float_hash_impl2(T v)
-        {
-            boost::hash_detail::call_frexp<T> frexp;
-            boost::hash_detail::call_ldexp<T> ldexp;
-
-            int exp = 0;
-
-            v = frexp(v, &exp);
-
-            // A postive value is easier to hash, so combine the
-            // sign with the exponent and use the absolute value.
-            if(v < 0) {
-                v = -v;
-                exp += limits<T>::max_exponent -
-                    limits<T>::min_exponent;
-            }
-
-            v = ldexp(v, limits<std::size_t>::digits);
-            std::size_t seed = static_cast<std::size_t>(v);
-            v -= static_cast<T>(seed);
-
-            // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
-            std::size_t const length
-                = (limits<T>::digits *
-                        boost::static_log2<limits<T>::radix>::value
-                        + limits<std::size_t>::digits - 1)
-                / limits<std::size_t>::digits;
-
-            for(std::size_t i = 0; i != length; ++i)
-            {
-                v = ldexp(v, limits<std::size_t>::digits);
-                std::size_t part = static_cast<std::size_t>(v);
-                v -= static_cast<T>(part);
-                hash_float_combine(seed, part);
-            }
-
-            hash_float_combine(seed, exp);
-
-            return seed;
-        }
-
-#if !defined(BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC)
-        template <class T>
-        inline std::size_t float_hash_impl(T v, ...)
-        {
-            typedef BOOST_DEDUCED_TYPENAME select_hash_type<T>::type type;
-            return float_hash_impl2(static_cast<type>(v));
-        }
-#endif
-    }
-}
-
 #if BOOST_HASH_USE_FPCLASSIFY
 
 #include <boost/config/no_tr1/cmath.hpp>
@@ -206,15 +61,8 @@ namespace boost
         template <class T>
         inline std::size_t float_hash_value(T v)
         {
-#if defined(fpclassify)
-            switch (fpclassify(v))
-#elif BOOST_HASH_CONFORMANT_FLOATS
-            switch (std::fpclassify(v))
-#else
             using namespace std;
-            switch (fpclassify(v))
-#endif
-            {
+            switch (fpclassify(v)) {
             case FP_ZERO:
                 return 0;
             case FP_INFINITE:
@@ -223,7 +71,7 @@ namespace boost
                 return (std::size_t)(-3);
             case FP_NORMAL:
             case FP_SUBNORMAL:
-                return float_hash_impl(v, 0);
+                return float_hash_impl(v);
             default:
                 BOOST_ASSERT(0);
                 return 0;
@@ -255,7 +103,7 @@ namespace boost
         template <class T>
         inline std::size_t float_hash_value(T v)
         {
-            return boost::hash_detail::is_zero(v) ? 0 : float_hash_impl(v, 0);
+            return boost::hash_detail::is_zero(v) ? 0 : float_hash_impl(v);
         }
     }
 }
@@ -264,8 +112,4 @@ namespace boost
 
 #undef BOOST_HASH_USE_FPCLASSIFY
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
 #endif

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

@@ -0,0 +1,91 @@
+
+// Copyright 2005-2009 Daniel James.
+// 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)
+
+// A general purpose hash function for non-zero floating point values.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_GENERIC_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_GENERIC_HEADER
+
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/integer/static_log2.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
+                              // not satisfy test. Loop body not executed 
+#endif
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        template <class T>
+        inline std::size_t float_hash_impl2(T v)
+        {
+            boost::hash_detail::call_frexp<T> frexp;
+            boost::hash_detail::call_ldexp<T> ldexp;
+        
+            int exp = 0;
+
+            v = frexp(v, &exp);
+
+            // A postive value is easier to hash, so combine the
+            // sign with the exponent and use the absolute value.
+            if(v < 0) {
+                v = -v;
+                exp += limits<T>::max_exponent -
+                    limits<T>::min_exponent;
+            }
+
+            v = ldexp(v, limits<std::size_t>::digits);
+            std::size_t seed = static_cast<std::size_t>(v);
+            v -= static_cast<T>(seed);
+
+            // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
+            std::size_t const length
+                = (limits<T>::digits *
+                        boost::static_log2<limits<T>::radix>::value
+                        + limits<std::size_t>::digits - 1)
+                / limits<std::size_t>::digits;
+
+            for(std::size_t i = 0; i != length; ++i)
+            {
+                v = ldexp(v, limits<std::size_t>::digits);
+                std::size_t part = static_cast<std::size_t>(v);
+                v -= static_cast<T>(part);
+                hash_float_combine(seed, part);
+            }
+
+            hash_float_combine(seed, exp);
+
+            return seed;
+        }
+
+        template <class T>
+        inline std::size_t float_hash_impl(T v)
+        {
+            typedef BOOST_DEDUCED_TYPENAME select_hash_type<T>::type type;
+            return float_hash_impl2(static_cast<type>(v));
+        }
+    }
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif

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

@@ -0,0 +1,56 @@
+
+// Copyright 2005-2009 Daniel James.
+// 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)
+
+// A non-portable hash function form non-zero floats on x86.
+//
+// Even if you're on an x86 platform, this might not work if their floating
+// point isn't set up as this expects. So this should only be used if it's
+// absolutely certain that it will work.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_X86_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_X86_HEADER
+
+#include <boost/cstdint.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        inline std::size_t float_hash_impl(float v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr;
+            return seed;
+        }
+
+        inline std::size_t float_hash_impl(double v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr++;
+            hash_float_combine(seed, *ptr);
+            return seed;
+        }
+
+        inline std::size_t float_hash_impl(long double v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr++;
+            hash_float_combine(seed, *ptr++);
+            hash_float_combine(seed, *(boost::uint16_t*)ptr);
+            return seed;
+        }
+    }
+}
+
+#endif

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

@@ -9,9 +9,8 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER)
 #define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 #include <boost/limits.hpp>

include/boost/functional/hash/extensions.hpp

@@ -13,34 +13,25 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
 #define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
 #include <boost/functional/hash/hash.hpp>
-#include <boost/detail/container_fwd.hpp>
+#include <boost/functional/hash/detail/container_fwd_0x.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
-#   include <array>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-#   include <tuple>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
-#   include <memory>
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 #include <boost/type_traits/is_array.hpp>
 #endif
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#include <boost/type_traits/is_const.hpp>
+#endif
+
 namespace boost
 {
     template <class A, class B>
@@ -158,7 +149,7 @@ namespace boost
         }
     }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
     template <typename... T>
     inline std::size_t hash_value(std::tuple<T...> const& v)
     {
@@ -229,7 +220,11 @@ namespace boost
             template <class Array>
             struct inner
             {
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
                 static std::size_t call(Array const& v)
+#else
+                static std::size_t call(Array& v)
+#endif
                 {
                     const int size = sizeof(v) / sizeof(*v);
                     return boost::hash_range(v, v + size);
@@ -251,6 +246,7 @@ namespace boost
     //
 
 
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T> struct hash
         : std::unary_function<T, std::size_t>
@@ -279,6 +275,93 @@ namespace boost
     };
 #endif
 
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    // On compilers without partial specialization, boost::hash<T>
+    // has already been declared to deal with pointers, so just
+    // need to supply the non-pointer version of hash_impl.
+
+    namespace hash_detail
+    {
+        template <bool IsPointer>
+        struct hash_impl;
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+        template <>
+        struct hash_impl<false>
+        {
+            template <class T>
+            struct inner
+                : std::unary_function<T, std::size_t>
+            {
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+                std::size_t operator()(T const& val) const
+                {
+                    return hash_value(val);
+                }
+#else
+                std::size_t operator()(T const& val) const
+                {
+                    return hash_detail::call_hash<T>::call(val);
+                }
+#endif
+            };
+        };
+
+#else // Visual C++ 6.5
+
+        // Visual C++ 6.5 has problems with nested member functions and
+        // applying const to const types in templates. So we get this:
+
+        template <bool IsConst>
+        struct hash_impl_msvc
+        {
+            template <class T>
+            struct inner
+                : public std::unary_function<T, std::size_t>
+            {
+                std::size_t operator()(T const& val) const
+                {
+                    return hash_detail::call_hash<T const>::call(val);
+                }
+
+                std::size_t operator()(T& val) const
+                {
+                    return hash_detail::call_hash<T>::call(val);
+                }
+            };
+        };
+
+        template <>
+        struct hash_impl_msvc<true>
+        {
+            template <class T>
+            struct inner
+                : public std::unary_function<T, std::size_t>
+            {
+                std::size_t operator()(T& val) const
+                {
+                    return hash_detail::call_hash<T>::call(val);
+                }
+            };
+        };
+        
+        template <class T>
+        struct hash_impl_msvc2
+            : public hash_impl_msvc<boost::is_const<T>::value>
+                    ::BOOST_NESTED_TEMPLATE inner<T> {};
+        
+        template <>
+        struct hash_impl<false>
+        {
+            template <class T>
+            struct inner : public hash_impl_msvc2<T> {};
+        };
+
+#endif // Visual C++ 6.5
+    }
+#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 }
 
 #endif

include/boost/functional/hash/hash.hpp

@@ -15,24 +15,20 @@
 #include <boost/functional/hash/detail/hash_float.hpp>
 #include <string>
 #include <boost/limits.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/utility/enable_if.hpp>
 
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#include <boost/type_traits/is_pointer.hpp>
+#endif
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
 #include <typeindex>
 #endif
 
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
-                              // are always of range '0' to '4294967295'.
-                              // Loop executes infinitely.
-#endif
-
+#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
 #endif
 
 namespace boost
@@ -42,8 +38,8 @@ namespace boost
         struct enable_hash_value { typedef std::size_t type; };
 
         template <typename T> struct basic_numbers {};
-        template <typename T> struct long_numbers;
-        template <typename T> struct ulong_numbers;
+        template <typename T> struct long_numbers {};
+        template <typename T> struct ulong_numbers {};
         template <typename T> struct float_numbers {};
 
         template <> struct basic_numbers<bool> :
@@ -72,14 +68,6 @@ namespace boost
             boost::hash_detail::enable_hash_value {};
 #endif
 
-        // long_numbers is defined like this to allow for separate
-        // specialization for long_long and int128_type, in case
-        // they conflict.
-        template <typename T> struct long_numbers2 {};
-        template <typename T> struct ulong_numbers2 {};
-        template <typename T> struct long_numbers : long_numbers2<T> {};
-        template <typename T> struct ulong_numbers : ulong_numbers2<T> {};
-
 #if !defined(BOOST_NO_LONG_LONG)
         template <> struct long_numbers<boost::long_long_type> :
             boost::hash_detail::enable_hash_value {};
@@ -87,13 +75,6 @@ namespace boost
             boost::hash_detail::enable_hash_value {};
 #endif
 
-#if defined(BOOST_HAS_INT128)
-        template <> struct long_numbers2<boost::int128_type> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct ulong_numbers2<boost::uint128_type> :
-            boost::hash_detail::enable_hash_value {};
-#endif
-
         template <> struct float_numbers<float> :
             boost::hash_detail::enable_hash_value {};
         template <> struct float_numbers<double> :
@@ -109,10 +90,6 @@ namespace boost
     template <typename T>
     typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);
 
-    template <typename T>
-    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
-        hash_value(T);
-
 #if !BOOST_WORKAROUND(__DMC__, <= 0x848)
     template <class T> std::size_t hash_value(T* const&);
 #else
@@ -129,7 +106,7 @@ namespace boost
 
     template <class Ch, class A>
     std::size_t hash_value(
-        std::basic_string<Ch, std::char_traits<Ch>, A> const&);
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
 
     template <typename T>
     typename boost::hash_detail::float_numbers<T>::type hash_value(T);
@@ -202,13 +179,6 @@ namespace boost
         return hash_detail::hash_value_unsigned(v);
     }
 
-    template <typename T>
-    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
-        hash_value(T v)
-    {
-        return static_cast<std::size_t>(v);
-    }
-
     // Implementation by Alberto Barbati and Dave Harris.
 #if !BOOST_WORKAROUND(__DMC__, <= 0x848)
     template <class T> std::size_t hash_value(T* const& v)
@@ -238,8 +208,13 @@ namespace boost
 #endif
 #endif
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    template <class T>
+    inline void hash_combine(std::size_t& seed, T& v)
+#else
     template <class T>
     inline void hash_combine(std::size_t& seed, T const& v)
+#endif
     {
         boost::hash<T> hasher;
         seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
@@ -313,7 +288,7 @@ namespace boost
 
     template <class Ch, class A>
     inline std::size_t hash_value(
-        std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
     {
         return hash_range(v.begin(), v.end());
     }
@@ -347,6 +322,7 @@ namespace boost
     //
     // These are undefined later.
 
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 #define BOOST_HASH_SPECIALIZE(type) \
     template <> struct hash<type> \
          : public std::unary_function<type, std::size_t> \
@@ -366,6 +342,45 @@ namespace boost
             return boost::hash_value(v); \
         } \
     };
+#else
+#define BOOST_HASH_SPECIALIZE(type) \
+    template <> struct hash<type> \
+         : public std::unary_function<type, std::size_t> \
+    { \
+        std::size_t operator()(type v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    }; \
+    \
+    template <> struct hash<const type> \
+         : public std::unary_function<const type, std::size_t> \
+    { \
+        std::size_t operator()(const type v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    };
+
+#define BOOST_HASH_SPECIALIZE_REF(type) \
+    template <> struct hash<type> \
+         : public std::unary_function<type, std::size_t> \
+    { \
+        std::size_t operator()(type const& v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    }; \
+    \
+    template <> struct hash<const type> \
+         : public std::unary_function<const type, std::size_t> \
+    { \
+        std::size_t operator()(type const& v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    };
+#endif
 
     BOOST_HASH_SPECIALIZE(bool)
     BOOST_HASH_SPECIALIZE(char)
@@ -395,11 +410,6 @@ namespace boost
     BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
 #endif
 
-#if defined(BOOST_HAS_INT128)
-    BOOST_HASH_SPECIALIZE(boost::int128_type)
-    BOOST_HASH_SPECIALIZE(boost::uint128_type)
-#endif
-
 #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
     BOOST_HASH_SPECIALIZE(std::type_index)
 #endif
@@ -409,6 +419,7 @@ namespace boost
 
 // Specializing boost::hash for pointers.
 
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T>
     struct hash<T*>
@@ -427,11 +438,51 @@ namespace boost
         }
     };
 
+#else
+
+    // For compilers without partial specialization, we define a
+    // boost::hash for all remaining types. But hash_impl is only defined
+    // for pointers in 'extensions.hpp' - so when BOOST_HASH_NO_EXTENSIONS
+    // is defined there will still be a compile error for types not supported
+    // in the standard.
+
+    namespace hash_detail
+    {
+        template <bool IsPointer>
+        struct hash_impl;
+
+        template <>
+        struct hash_impl<true>
+        {
+            template <class T>
+            struct inner
+                : public std::unary_function<T, std::size_t>
+            {
+                std::size_t operator()(T val) const
+                {
+#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590)
+                    return boost::hash_value(val);
+#else
+                    std::size_t x = static_cast<std::size_t>(
+                        reinterpret_cast<std::ptrdiff_t>(val));
+
+                    return x + (x >> 3);
+#endif
+                }
+            };
+        };
+    }
+
+    template <class T> struct hash
+        : public boost::hash_detail::hash_impl<boost::is_pointer<T>::value>
+            ::BOOST_NESTED_TEMPLATE inner<T>
+    {
+    };
+
+#endif
 }
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
+#undef BOOST_HASH_CHAR_TRAITS
 
 #endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
 

include/boost/functional/hash/hash_fwd.hpp

@@ -10,11 +10,11 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP)
 #define BOOST_FUNCTIONAL_HASH_FWD_HPP
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
+#include <boost/config.hpp>
 #include <cstddef>
 #include <boost/detail/workaround.hpp>
 
@@ -22,7 +22,11 @@ namespace boost
 {
     template <class T> struct hash;
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    template <class T> void hash_combine(std::size_t& seed, T& v);
+#else
     template <class T> void hash_combine(std::size_t& seed, T const& v);
+#endif
 
     template <class It> std::size_t hash_range(It, It);
     template <class It> void hash_range(std::size_t&, It, It);

include/boost/functional/hash_fwd.hpp

@@ -3,9 +3,5 @@
 // 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 <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
 #include <boost/functional/hash/hash_fwd.hpp>
+

test/Jamfile.v2

@@ -1,5 +1,5 @@
 
-# Copyright 2005-2012 Daniel James.
+# Copyright 2005-2011 Daniel James.
 # 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)
 
@@ -9,10 +9,10 @@ project hash-tests
     : requirements
         <warnings>all
         <toolset>intel:<warnings>on
-        #<toolset>intel:<cxxflags>-strict-ansi
+        <toolset>intel:<cxxflags>-strict-ansi
         <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
         <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
-        #<toolset>msvc:<warnings-as-errors>on
+        <toolset>msvc:<warnings-as-errors>on
         #<toolset>gcc:<warnings-as-errors>on
         #<toolset>darwin:<warnings-as-errors>on
     ;
@@ -22,7 +22,6 @@ test-suite functional/hash
         [ run hash_fwd_test_1.cpp ]
         [ run hash_fwd_test_2.cpp ]
         [ run hash_number_test.cpp ]
-        [ run hash_enum_test.cpp ]
         [ run hash_pointer_test.cpp ]
         [ run hash_function_pointer_test.cpp ]
         [ run hash_float_test.cpp ]
@@ -52,6 +51,7 @@ test-suite functional/hash
         [ run implicit_test.cpp ]
         [ run hash_no_ext_macro_1.cpp ]
         [ run hash_no_ext_macro_2.cpp ]
+        [ compile deprecated_container_fwd.cpp ]
     ;
 
 test-suite functional/hash_no_ext
@@ -65,17 +65,4 @@ test-suite functional/hash_no_ext
         [ run link_test.cpp link_test_2.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_link_test ]
     ;
 
-# Tests to see if the floating point hash is using the binary hash.
-# Not run normally because on some platforms these should fail.
-test-suite functional/hash_no_generic_float
-    :
-        [ run hash_float_test.cpp
-            : : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC
-            : hash_float_test_no_generic ]
-        [ run hash_long_double_test.cpp
-            : : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC
-            : hash_long_double_test_no_generic ]
-    ;
-explicit functional/hash_no_generic_float ;
-
 build-project ../examples ;

test/compile_time.hpp

@@ -11,6 +11,6 @@ template <class T>
 void compile_time_tests(T*)
 {
     BOOST_STATIC_ASSERT((boost::is_base_and_derived<
-        std::unary_function<T, std::size_t>, BOOST_HASH_TEST_NAMESPACE::hash<T> >::value));
+        std::unary_function<T, std::size_t>, HASH_NAMESPACE::hash<T> >::value));
 }
 

test/config.hpp

@@ -3,13 +3,13 @@
 // 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)
 
-#if defined(BOOST_HASH_TEST_STD)
-#  define BOOST_HASH_TEST_STD_INCLUDES
-#  define BOOST_HASH_TEST_NAMESPACE std
+#if defined(TEST_STD)
+#  define TEST_STD_INCLUDES
+#  define HASH_NAMESPACE std
 #else
-#  define BOOST_HASH_TEST_NAMESPACE boost
+#  define HASH_NAMESPACE boost
 #  if !defined(BOOST_HASH_NO_EXTENSIONS)
-#    define BOOST_HASH_TEST_EXTENSIONS
+#    define TEST_EXTENSIONS
 #  endif
 #endif
 

test/deprecated_container_fwd.cpp

@@ -0,0 +1,14 @@
+
+// Copyright 2012 Daniel James.
+// 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 <boost/functional/detail/container_fwd.hpp>
+
+typedef std::vector<int, std::allocator<int> > int_vector;
+
+#include <vector>
+
+int main() {
+    int_vector x;
+}

test/extra/Jamfile.v2

@@ -1,13 +0,0 @@
-
-# Copyright 2012 Daniel James.
-# 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)
-
-import testing ;
-
-build-project .. ;
-
-test-suite functional/hash/config
-    :
-        [ compile check_float_funcs.cpp ]
-    ;

test/extra/check_float_funcs.cpp

@@ -1,58 +0,0 @@
-
-// Copyright 2012 Daniel James.
-// 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 <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <cmath>
-
-namespace test
-{
-    template <class T1>
-    struct check_return_type
-    {
-        template <class T2>
-        static void equals(T2)
-        {
-            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
-        }
-
-        template <class T2>
-        static void equals_ref(T2&)
-        {
-            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
-        }
-
-        template <class T2>
-        static void convertible(T2)
-        {
-            BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
-        }
-    };
-}
-
-int main() {
-    float f = 0;
-    double d = 0;
-    long double l = 0;
-
-    test::check_return_type<float>::equals(std::ldexp(f, 0));
-    test::check_return_type<double>::equals(std::ldexp(d, 0));
-    test::check_return_type<long double>::equals(std::ldexp(l, 0));
-
-    int dummy = 0;
-
-    test::check_return_type<float>::equals(std::frexp(f, &dummy));
-    test::check_return_type<double>::equals(std::frexp(d, &dummy));
-    test::check_return_type<long double>::equals(std::frexp(l, &dummy));
-
-#if BOOST_HASH_USE_FPCLASSIFY
-
-    int (*fpc1)(float) = std::fpclassify;
-    int (*fpc2)(double) = std::fpclassify;
-    int (*fpc3)(long double) = std::fpclassify;
-
-#endif
-}

test/hash_built_in_array_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 void array_int_test()
 {
@@ -27,47 +27,47 @@ void array_int_test()
         8, -12, 23, 65, 45,
         -1, 93, -54, 987, 3
     };
-    BOOST_HASH_TEST_NAMESPACE::hash<int[25]> hasher1;
+    HASH_NAMESPACE::hash<int[25]> hasher1;
 
     const int length2 = 1;
     int array2[1] = {3};
-    BOOST_HASH_TEST_NAMESPACE::hash<int[1]> hasher2;
+    HASH_NAMESPACE::hash<int[1]> hasher2;
 
     const int length3 = 2;
     int array3[2] = {2, 3};
-    BOOST_HASH_TEST_NAMESPACE::hash<int[2]> hasher3;
+    HASH_NAMESPACE::hash<int[2]> hasher3;
 
     BOOST_TEST(hasher1(array1)
-            == BOOST_HASH_TEST_NAMESPACE::hash_range(array1, array1 + length1));
+            == HASH_NAMESPACE::hash_range(array1, array1 + length1));
     BOOST_TEST(hasher2(array2)
-            == BOOST_HASH_TEST_NAMESPACE::hash_range(array2, array2 + length2));
+            == HASH_NAMESPACE::hash_range(array2, array2 + length2));
     BOOST_TEST(hasher3(array3)
-            == BOOST_HASH_TEST_NAMESPACE::hash_range(array3, array3 + length3));
+            == HASH_NAMESPACE::hash_range(array3, array3 + length3));
 }
 
 void two_dimensional_array_test()
 {
     int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
-    BOOST_HASH_TEST_NAMESPACE::hash<int[3][2]> hasher;
+    HASH_NAMESPACE::hash<int[3][2]> hasher;
 
     std::size_t seed1 = 0;
     for(int i = 0; i < 3; ++i)
     {
         std::size_t seed2 = 0;
         for(int j = 0; j < 2; ++j)
-            BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, array[i][j]);
-        BOOST_HASH_TEST_NAMESPACE::hash_combine(seed1, seed2);
+            HASH_NAMESPACE::hash_combine(seed2, array[i][j]);
+        HASH_NAMESPACE::hash_combine(seed1, seed2);
     }
 
     BOOST_TEST(hasher(array) == seed1);
-    BOOST_TEST(hasher(array) == BOOST_HASH_TEST_NAMESPACE::hash_range(array, array + 3));
+    BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3));
 }
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     array_int_test();
     two_dimensional_array_test();
 #endif

test/hash_complex_test.cpp

@@ -5,13 +5,13 @@
 
 #include "./config.hpp"
 
-#if !defined(BOOST_HASH_TEST_EXTENSIONS)
+#if !defined(TEST_EXTENSIONS)
 
 int main() {}
 
 #else
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
@@ -35,7 +35,7 @@ int main() {}
 #endif
 #endif
 
-#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 
@@ -46,11 +46,11 @@ int main() {}
 template <class T>
 void generic_complex_tests(std::complex<T> v)
 {
-    BOOST_HASH_TEST_NAMESPACE::hash<std::complex<T> > complex_hasher;
+    HASH_NAMESPACE::hash<std::complex<T> > complex_hasher;
 
     BOOST_TEST(complex_hasher(v) == complex_hasher(v));
 
-    BOOST_HASH_TEST_NAMESPACE::hash<T> real_hasher;
+    HASH_NAMESPACE::hash<T> real_hasher;
     T real = v.real();
     T imag = v.imag();
 
@@ -107,4 +107,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS

test/hash_custom_test.cpp

@@ -41,8 +41,8 @@ namespace boost
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -51,7 +51,7 @@ namespace boost
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <vector>
 #include <string>
@@ -59,13 +59,13 @@ namespace boost
 
 void custom_tests()
 {
-    BOOST_HASH_TEST_NAMESPACE::hash<test::custom> custom_hasher;
+    HASH_NAMESPACE::hash<test::custom> custom_hasher;
     BOOST_TEST(custom_hasher(10) == 100u);
     test::custom x(55);
     BOOST_TEST(custom_hasher(x) == 550u);
 
     {
-        using namespace BOOST_HASH_TEST_NAMESPACE;
+        using namespace HASH_NAMESPACE;
         BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
@@ -75,25 +75,25 @@ void custom_tests()
     custom_vector.push_back(35);
 
     std::size_t seed = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom(5));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom(25));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom(35));
+    HASH_NAMESPACE::hash_combine(seed, test::custom(5));
+    HASH_NAMESPACE::hash_combine(seed, test::custom(25));
+    HASH_NAMESPACE::hash_combine(seed, test::custom(35));
 
     std::size_t seed2 = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 50u);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 250u);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 350u);
+    HASH_NAMESPACE::hash_combine(seed2, 50u);
+    HASH_NAMESPACE::hash_combine(seed2, 250u);
+    HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed == BOOST_HASH_TEST_NAMESPACE::hash_range(
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
         custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
     return boost::report_errors();

test/hash_deque_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <deque>
 
@@ -23,11 +23,11 @@ using std::deque;
 #define CONTAINER_TYPE deque
 #include "./hash_sequence_test.hpp"
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     deque_tests::deque_hash_integer_tests();
 #endif
 

test/hash_enum_test.cpp

@@ -1,63 +0,0 @@
-
-// Copyright 2012 Daniel James.
-// 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"
-
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
-#  include <functional>
-#else
-#  include <boost/functional/hash.hpp>
-#endif
-
-#include <boost/detail/lightweight_test.hpp>
-#include "./compile_time.hpp"
-
-namespace test {
-    enum enum_override { enum_override1, enum_override2 };
-    std::size_t hash_value(enum_override) { return 896532; }
-
-    enum enum1 { enum1a };
-    enum enum2 { enum2a, enum2b };
-    enum enum3 { enum3a = 574, enum3b };
-    enum enum4 { enum4a = -12574, enum4b };
-}
-
-int main() {
-    compile_time_tests((test::enum1*) 0);
-    compile_time_tests((test::enum2*) 0);
-    compile_time_tests((test::enum3*) 0);
-    compile_time_tests((test::enum4*) 0);
-    compile_time_tests((test::enum_override*) 0);
-
-    BOOST_HASH_TEST_NAMESPACE::hash<test::enum1> hash1;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::enum2> hash2;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::enum3> hash3;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::enum4> hash4;
-
-    BOOST_TEST(hash1(test::enum1a) == hash1(test::enum1a));
-
-    BOOST_TEST(hash2(test::enum2a) == hash2(test::enum2a));
-    BOOST_TEST(hash2(test::enum2a) != hash2(test::enum2b));
-    BOOST_TEST(hash2(test::enum2b) == hash2(test::enum2b));
-
-    BOOST_TEST(hash3(test::enum3a) == hash3(test::enum3a));
-    BOOST_TEST(hash3(test::enum3a) != hash3(test::enum3b));
-    BOOST_TEST(hash3(test::enum3b) == hash3(test::enum3b));
-
-    BOOST_TEST(hash4(test::enum4a) == hash4(test::enum4a));
-    BOOST_TEST(hash4(test::enum4a) != hash4(test::enum4b));
-    BOOST_TEST(hash4(test::enum4b) == hash4(test::enum4b));
-
-    BOOST_HASH_TEST_NAMESPACE::hash<test::enum_override> hash_override;
-
-    BOOST_TEST(hash_override(test::enum_override1) ==
-        hash_override(test::enum_override1));
-    BOOST_TEST(hash_override(test::enum_override1) ==
-        hash_override(test::enum_override2));
-    BOOST_TEST(hash_override(test::enum_override1) ==
-        hash_override(test::enum_override1));
-
-    return boost::report_errors();
-}

test/hash_float_test.hpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
@@ -30,7 +30,7 @@
 #endif
 #endif
 
-#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 
@@ -43,7 +43,7 @@ void float_tests(char const* name, T* = 0)
 {
     std::cerr
         <<  "\n"
-        <<  "Testing " BOOST_STRINGIZE(BOOST_HASH_TEST_NAMESPACE) "::hash<"
+        <<  "Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"
         <<  name
         <<  ">\n"
         <<  "\n"
@@ -70,7 +70,7 @@ void float_tests(char const* name, T* = 0)
         <<  "\n"
         ;
 
-    BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
+    HASH_NAMESPACE::hash<T> x1;
 
     T zero = 0;
     T minus_zero = (T) -1 * zero;
@@ -78,9 +78,9 @@ void float_tests(char const* name, T* = 0)
     BOOST_TEST(zero == minus_zero);
     BOOST_TEST(x1(zero) == x1(minus_zero));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(zero) == BOOST_HASH_TEST_NAMESPACE::hash_value(zero));
-    BOOST_TEST(x1(minus_zero) == BOOST_HASH_TEST_NAMESPACE::hash_value(minus_zero));
+#if defined(TEST_EXTENSIONS)
+    BOOST_TEST(x1(zero) == HASH_NAMESPACE::hash_value(zero));
+    BOOST_TEST(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
 #endif
 
     BOOST_TEST(x1(zero) != x1(0.5));
@@ -106,10 +106,10 @@ void float_tests(char const* name, T* = 0)
         T minus_infinity2 = (T) -1. / zero;
         T minus_infinity3 = (T) 1. / minus_zero;
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-        BOOST_TEST(x1(infinity) == BOOST_HASH_TEST_NAMESPACE::hash_value(infinity));
+#if defined(TEST_EXTENSIONS)
+        BOOST_TEST(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
         BOOST_TEST(x1(minus_infinity)
-                == BOOST_HASH_TEST_NAMESPACE::hash_value(minus_infinity));
+                == HASH_NAMESPACE::hash_value(minus_infinity));
 #endif
 
         if(infinity == infinity2)
@@ -191,12 +191,12 @@ void float_tests(char const* name, T* = 0)
     BOOST_TEST(three_quarter_max != -three_quarter_max);
 
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(max) == BOOST_HASH_TEST_NAMESPACE::hash_value(max));
-    BOOST_TEST(x1(half_max) == BOOST_HASH_TEST_NAMESPACE::hash_value(half_max));
-    BOOST_TEST(x1(quarter_max) == BOOST_HASH_TEST_NAMESPACE::hash_value(quarter_max));
+#if defined(TEST_EXTENSIONS)
+    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) ==
-        BOOST_HASH_TEST_NAMESPACE::hash_value(three_quarter_max));
+        HASH_NAMESPACE::hash_value(three_quarter_max));
 #endif
 
     // The '!=' tests could legitimately fail, but with my hash it indicates a
@@ -227,16 +227,16 @@ void float_tests(char const* name, T* = 0)
     if(v1 == v2)
         BOOST_TEST(x1(v1) == x1(v2));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(v1) == BOOST_HASH_TEST_NAMESPACE::hash_value(v1));
-    BOOST_TEST(x1(v2) == BOOST_HASH_TEST_NAMESPACE::hash_value(v2));
+#if defined(TEST_EXTENSIONS)
+    BOOST_TEST(x1(v1) == HASH_NAMESPACE::hash_value(v1));
+    BOOST_TEST(x1(v2) == HASH_NAMESPACE::hash_value(v2));
 #endif
     
 #endif
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
     BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_value(
+            HASH_NAMESPACE::hash_value(
                 boost::hash_detail::limits<T>::epsilon()));
 #endif
 
@@ -269,12 +269,12 @@ void float_tests(char const* name, T* = 0)
         if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(zero)) {
             std::cerr<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n";
         }
-#if !BOOST_WORKAROUND(__DECCXX_VER,<70190006) && defined(BOOST_HASH_TEST_EXTENSIONS)
+#if !BOOST_WORKAROUND(__DECCXX_VER,<70190006) && defined(TEST_EXTENSIONS)
         // The Tru64/CXX standard library prior to 7.1 contains a bug in the
         // 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()) !=
-            BOOST_HASH_TEST_NAMESPACE::hash_value(
+            HASH_NAMESPACE::hash_value(
                 boost::hash_detail::limits<T>::denorm_min()))
         {
             std::cerr
@@ -282,7 +282,7 @@ void float_tests(char const* name, T* = 0)
                 <<  x1(boost::hash_detail::limits<T>::denorm_min())
                 <<  "\nhash_value(boost::hash_detail::limits<T>::denorm_min())"
                     " = "
-                <<  BOOST_HASH_TEST_NAMESPACE::hash_value(
+                <<  HASH_NAMESPACE::hash_value(
                         boost::hash_detail::limits<T>::denorm_min())
                 <<  "\nx1(0) = "
                 <<  x1(0)
@@ -292,13 +292,13 @@ void float_tests(char const* name, T* = 0)
     }
 
 // NaN also causes borland to crash.
-#if !defined(__BORLANDC__) && defined(BOOST_HASH_TEST_EXTENSIONS)
+#if !defined(__BORLANDC__) && defined(TEST_EXTENSIONS)
     if(boost::hash_detail::limits<T>::has_quiet_NaN) {
         if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(1.0)) {
             std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
         }
         BOOST_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_value(
+            HASH_NAMESPACE::hash_value(
                 boost::hash_detail::limits<T>::quiet_NaN()));
     }
 #endif

test/hash_friend_test.cpp

@@ -44,8 +44,8 @@ namespace boost
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -54,7 +54,7 @@ namespace boost
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <vector>
 #include <string>
@@ -62,13 +62,13 @@ namespace boost
 
 void custom_tests()
 {
-    BOOST_HASH_TEST_NAMESPACE::hash<test::custom<int> > custom_hasher;
+    HASH_NAMESPACE::hash<test::custom<int> > custom_hasher;
     BOOST_TEST(custom_hasher(10) == 100u);
     test::custom<int> x(55);
     BOOST_TEST(custom_hasher(x) == 550u);
 
     {
-        using namespace BOOST_HASH_TEST_NAMESPACE;
+        using namespace HASH_NAMESPACE;
         BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
@@ -78,25 +78,25 @@ void custom_tests()
     custom_vector.push_back(35);
 
     std::size_t seed = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom<int>(5));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom<int>(25));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom<int>(35));
+    HASH_NAMESPACE::hash_combine(seed, test::custom<int>(5));
+    HASH_NAMESPACE::hash_combine(seed, test::custom<int>(25));
+    HASH_NAMESPACE::hash_combine(seed, test::custom<int>(35));
 
     std::size_t seed2 = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 50u);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 250u);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 350u);
+    HASH_NAMESPACE::hash_combine(seed2, 50u);
+    HASH_NAMESPACE::hash_combine(seed2, 250u);
+    HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed == BOOST_HASH_TEST_NAMESPACE::hash_range(
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
         custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
     return boost::report_errors();

test/hash_function_pointer_test.cpp

@@ -5,13 +5,17 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
 #endif
 
 #include <boost/detail/lightweight_test.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
 #include "./compile_time.hpp"
 
 void void_func1() { static int x = 1; ++x; }
@@ -24,8 +28,8 @@ void function_pointer_tests()
     compile_time_tests((void(**)()) 0);
     compile_time_tests((int(**)(int)) 0);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<void(*)()> hasher_void;
-    BOOST_HASH_TEST_NAMESPACE::hash<int(*)(int)> hasher_int;
+    HASH_NAMESPACE::hash<void(*)()> hasher_void;
+    HASH_NAMESPACE::hash<int(*)(int)> hasher_int;
 
     BOOST_TEST(&void_func1 != &void_func2);
     BOOST_TEST(&int_func1 != &int_func2);
@@ -38,11 +42,11 @@ void function_pointer_tests()
     BOOST_TEST(hasher_int(&int_func1) == hasher_int(&int_func1));
     BOOST_TEST(hasher_int(&int_func1) != hasher_int(&int_func2));
     BOOST_TEST(hasher_int(&int_func1) != hasher_int(0));
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
     BOOST_TEST(hasher_void(&void_func1)
-            == BOOST_HASH_TEST_NAMESPACE::hash_value(&void_func1));
+            == HASH_NAMESPACE::hash_value(&void_func1));
     BOOST_TEST(hasher_int(&int_func1)
-            == BOOST_HASH_TEST_NAMESPACE::hash_value(&int_func1));
+            == HASH_NAMESPACE::hash_value(&int_func1));
 
     // This isn't specified in Peter's proposal:
     BOOST_TEST(hasher_void(0) == 0);

test/hash_fwd_test.hpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
+#if defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES)
 #include <boost/functional/hash_fwd.hpp>
 
 #include <boost/config.hpp>
@@ -25,7 +25,7 @@ namespace test {
     template <class T>
     std::size_t hash_value(test_type1<T> const& x)
     {
-        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
+        HASH_NAMESPACE::hash<T> hasher;
         return hasher(x.value);
     }
 #endif
@@ -42,8 +42,8 @@ namespace test {
     std::size_t hash_value(test_type2<T> const& x)
     {
         std::size_t seed = 0;
-        BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value1);
-        BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value2);
+        HASH_NAMESPACE::hash_combine(seed, x.value1);
+        HASH_NAMESPACE::hash_combine(seed, x.value2);
         return seed;
     }
 #endif
@@ -61,8 +61,8 @@ namespace test {
     std::size_t hash_value(test_type3<T> const& x)
     {
         std::size_t seed =
-            BOOST_HASH_TEST_NAMESPACE::hash_range(x.values.begin(), x.values.end());
-        BOOST_HASH_TEST_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
+            HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
+        HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
         return seed;
     }
 #endif
@@ -76,7 +76,7 @@ namespace boost
     template <class T>
     std::size_t hash_value(test::test_type1<T> const& x)
     {
-        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
+        HASH_NAMESPACE::hash<T> hasher;
         return hasher(x.value);
     }
 
@@ -84,8 +84,8 @@ namespace boost
     std::size_t hash_value(test::test_type2<T> const& x)
     {
         std::size_t seed = 0;
-        BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value1);
-        BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value2);
+        HASH_NAMESPACE::hash_combine(seed, x.value1);
+        HASH_NAMESPACE::hash_combine(seed, x.value2);
         return seed;
     }
 
@@ -93,8 +93,8 @@ namespace boost
     std::size_t hash_value(test::test_type3<T> const& x)
     {
         std::size_t seed =
-            BOOST_HASH_TEST_NAMESPACE::hash_range(x.values.begin(), x.values.end());
-        BOOST_HASH_TEST_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
+            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

@@ -11,7 +11,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
+#if defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES)
 
 #include <boost/functional/hash.hpp>
 #include <string>
@@ -21,10 +21,10 @@ void fwd_test1()
     test::test_type1<int> x(5);
     test::test_type1<std::string> y("Test");
 
-    BOOST_HASH_TEST_NAMESPACE::hash<int> hasher_int;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::string> hasher_string;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::test_type1<int> > hasher_test_int;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::test_type1<std::string> > hasher_test_string;
+    HASH_NAMESPACE::hash<int> hasher_int;
+    HASH_NAMESPACE::hash<std::string> hasher_string;
+    HASH_NAMESPACE::hash<test::test_type1<int> > hasher_test_int;
+    HASH_NAMESPACE::hash<test::test_type1<std::string> > hasher_test_string;
 
     BOOST_TEST(hasher_int(5) == hasher_test_int(x));
     BOOST_TEST(hasher_string("Test") == hasher_test_string(y));
@@ -36,15 +36,15 @@ void fwd_test2()
     test::test_type2<std::string> y("Test1", "Test2");
 
     std::size_t seed1 = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed1, 5);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed1, 10);
+    HASH_NAMESPACE::hash_combine(seed1, 5);
+    HASH_NAMESPACE::hash_combine(seed1, 10);
 
     std::size_t seed2 = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, std::string("Test1"));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, std::string("Test2"));
+    HASH_NAMESPACE::hash_combine(seed2, std::string("Test1"));
+    HASH_NAMESPACE::hash_combine(seed2, std::string("Test2"));
 
-    BOOST_HASH_TEST_NAMESPACE::hash<test::test_type2<int> > hasher_test_int;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::test_type2<std::string> > hasher_test_string;
+    HASH_NAMESPACE::hash<test::test_type2<int> > hasher_test_int;
+    HASH_NAMESPACE::hash<test::test_type2<std::string> > hasher_test_string;
 
     BOOST_TEST(seed1 == hasher_test_int(x));
     BOOST_TEST(seed2 == hasher_test_string(y));
@@ -69,15 +69,15 @@ void fwd_test3()
     test::test_type3<std::string> y(values2.begin(), values2.end());
 
     std::size_t seed1 =
-        BOOST_HASH_TEST_NAMESPACE::hash_range(values1.begin(), values1.end());
-    BOOST_HASH_TEST_NAMESPACE::hash_range(seed1, values1.begin(), values1.end());
+        HASH_NAMESPACE::hash_range(values1.begin(), values1.end());
+    HASH_NAMESPACE::hash_range(seed1, values1.begin(), values1.end());
 
     std::size_t seed2 =
-        BOOST_HASH_TEST_NAMESPACE::hash_range(values2.begin(), values2.end());
-    BOOST_HASH_TEST_NAMESPACE::hash_range(seed2, values2.begin(), values2.end());
+        HASH_NAMESPACE::hash_range(values2.begin(), values2.end());
+    HASH_NAMESPACE::hash_range(seed2, values2.begin(), values2.end());
 
-    BOOST_HASH_TEST_NAMESPACE::hash<test::test_type3<int> > hasher_test_int;
-    BOOST_HASH_TEST_NAMESPACE::hash<test::test_type3<std::string> > hasher_test_string;
+    HASH_NAMESPACE::hash<test::test_type3<int> > hasher_test_int;
+    HASH_NAMESPACE::hash<test::test_type3<std::string> > hasher_test_string;
 
     BOOST_TEST(seed1 == hasher_test_int(x));
     BOOST_TEST(seed2 == hasher_test_string(y));
@@ -87,7 +87,7 @@ void fwd_test3()
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     fwd_test1();
     fwd_test2();
     fwd_test3();

test/hash_fwd_test_2.cpp

@@ -8,7 +8,7 @@
 
 #include "./config.hpp"
 
-#if !defined(BOOST_HASH_TEST_EXTENSIONS) || defined(BOOST_HASH_TEST_STD_INCLUDES)
+#if !defined(TEST_EXTENSIONS) || defined(TEST_STD_INCLUDES)
 
 int main() {}
 
@@ -44,4 +44,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif // defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
+#endif // defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES)

test/hash_global_namespace_test.cpp

@@ -42,8 +42,8 @@ namespace boost
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -52,7 +52,7 @@ namespace boost
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <vector>
 #include <string>
@@ -60,13 +60,13 @@ namespace boost
 
 void custom_tests()
 {
-    BOOST_HASH_TEST_NAMESPACE::hash<custom> custom_hasher;
+    HASH_NAMESPACE::hash<custom> custom_hasher;
     BOOST_TEST(custom_hasher(10) == 100u);
     custom x(55);
     BOOST_TEST(custom_hasher(x) == 550u);
 
     {
-        using namespace BOOST_HASH_TEST_NAMESPACE;
+        using namespace HASH_NAMESPACE;
         BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
@@ -76,26 +76,26 @@ void custom_tests()
     custom_vector.push_back(35);
 
     std::size_t seed = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, custom(5));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, custom(25));
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, custom(35));
+    HASH_NAMESPACE::hash_combine(seed, custom(5));
+    HASH_NAMESPACE::hash_combine(seed, custom(25));
+    HASH_NAMESPACE::hash_combine(seed, custom(35));
 
     std::size_t seed2 = 0;
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 50u);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 250u);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 350u);
+    HASH_NAMESPACE::hash_combine(seed2, 50u);
+    HASH_NAMESPACE::hash_combine(seed2, 250u);
+    HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed == BOOST_HASH_TEST_NAMESPACE::hash_range(
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
         custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
     return boost::report_errors();

test/hash_list_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <list>
 
@@ -23,11 +23,11 @@ using std::list;
 #define CONTAINER_TYPE list
 #include "./hash_sequence_test.hpp"
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     list_tests::list_hash_integer_tests();
 #endif
 

test/hash_map_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -17,7 +17,7 @@
 
 #include <map>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 using std::map;
 #define CONTAINER_TYPE map
@@ -27,11 +27,11 @@ using std::multimap;
 #define CONTAINER_TYPE multimap
 #include "./hash_map_test.hpp"
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     map_tests::map_hash_integer_tests();
     multimap_tests::multimap_hash_integer_tests();
 #endif

test/hash_map_test.hpp

@@ -38,16 +38,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         containers[9].insert(pair(key(-1),value(3)));
         containers[9].insert(pair(key(-1),value(3)));
 
-        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
+        HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
             BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
             BOOST_TEST(hasher(containers[i2]) ==
-                    BOOST_HASH_TEST_NAMESPACE::hash_value(containers[i2]));
+                    HASH_NAMESPACE::hash_value(containers[i2]));
 
             BOOST_TEST(hasher(containers[i2])
-                    == BOOST_HASH_TEST_NAMESPACE::hash_range(
+                    == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {

test/hash_no_ext_fail_test.cpp

@@ -11,7 +11,7 @@
 #  define BOOST_HASH_NO_EXTENSIONS
 #endif
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
@@ -21,7 +21,7 @@ template <class T> void ignore(T const&) {}
 
 int main()
 {
-    BOOST_HASH_TEST_NAMESPACE::hash< int[10] > hasher;
+    HASH_NAMESPACE::hash< int[10] > hasher;
     ignore(hasher);
 
     return 0;

test/hash_no_ext_macro_1.cpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
 
 // Include header without BOOST_HASH_NO_EXTENSIONS defined
 #  if defined(BOOST_HASH_NO_EXTENSIONS)
@@ -23,14 +23,14 @@
 
 int main()
 {
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
     std::deque<int> x;
 
     x.push_back(1);
     x.push_back(2);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<std::deque<int> > hasher;
-    BOOST_TEST(hasher(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
+    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

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
 
 // Include header with BOOST_HASH_NO_EXTENSIONS defined
 #  if !defined(BOOST_HASH_NO_EXTENSIONS)
@@ -23,14 +23,14 @@
 
 int main()
 {
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
     std::map<int, int> x;
 
     x.insert(std::map<int, int>::value_type(53, -42));
     x.insert(std::map<int, int>::value_type(14, -75));
 
-    BOOST_HASH_TEST_NAMESPACE::hash<std::map<int, int> > hasher;
-    BOOST_TEST(hasher(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
+    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

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
@@ -16,7 +16,8 @@
 
 #include <boost/preprocessor/cat.hpp>
 #include <boost/functional/hash/detail/limits.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
 
 #include "./compile_time.hpp"
 
@@ -27,34 +28,10 @@
 #pragma warning(disable:4310) // cast truncates constant value
 #endif
 
-#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 
-template <class T>
-void numeric_extra_tests(typename
-    boost::enable_if_c<boost::hash_detail::limits<T>::is_integer,
-        void*>::type = 0)
-{
-    typedef boost::hash_detail::limits<T> limits;
-
-    if(limits::is_signed ||
-        limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
-    {
-        BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
-    }
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
-}
-
-template <class T>
-void numeric_extra_tests(typename
-    boost::disable_if_c<boost::hash_detail::limits<T>::is_integer,
-        void*>::type = 0)
-{
-}
-
 template <class T>
 void numeric_test(T*)
 {
@@ -62,8 +39,8 @@ void numeric_test(T*)
 
     compile_time_tests((T*) 0);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<T> x2;
+    HASH_NAMESPACE::hash<T> x1;
+    HASH_NAMESPACE::hash<T> x2;
 
     T v1 = (T) -5;
     BOOST_TEST(x1(v1) == x2(v1));
@@ -74,13 +51,23 @@ void numeric_test(T*)
     BOOST_TEST(x1(T(5) - T(5)) == x2(T(0)));
     BOOST_TEST(x1(T(6) + T(4)) == x2(T(10)));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(T(-5)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(-5)));
-    BOOST_TEST(x1(T(0)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(0)));
-    BOOST_TEST(x1(T(10)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(10)));
-    BOOST_TEST(x1(T(25)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(25)));
+#if defined(TEST_EXTENSIONS)
+    BOOST_TEST(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
+    BOOST_TEST(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
+    BOOST_TEST(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
+    BOOST_TEST(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
 
-    numeric_extra_tests<T>();
+    if (limits::is_integer)
+    {
+        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));
+    }
 #endif
 }
 
@@ -91,8 +78,8 @@ void limits_test(T*)
 
     if(limits::is_specialized)
     {
-        BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
-        BOOST_HASH_TEST_NAMESPACE::hash<T> x2;
+        HASH_NAMESPACE::hash<T> x1;
+        HASH_NAMESPACE::hash<T> x2;
 
         T min_value = (limits::min)();
         T max_value = (limits::max)();
@@ -100,15 +87,15 @@ void limits_test(T*)
         BOOST_TEST(x1(min_value) == x2((limits::min)()));
         BOOST_TEST(x1(max_value) == x2((limits::max)()));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-        BOOST_TEST(x1(min_value) == BOOST_HASH_TEST_NAMESPACE::hash_value(min_value));
-        BOOST_TEST(x1(max_value) == BOOST_HASH_TEST_NAMESPACE::hash_value(max_value));
+#if defined(TEST_EXTENSIONS)
+        BOOST_TEST(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
+        BOOST_TEST(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
 
         if (limits::is_integer)
         {
-            BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(min_value)
+            BOOST_TEST(HASH_NAMESPACE::hash_value(min_value)
                     == std::size_t(min_value));
-            BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(max_value)
+            BOOST_TEST(HASH_NAMESPACE::hash_value(max_value)
                     == std::size_t(max_value));
         }
 #endif
@@ -120,8 +107,8 @@ void poor_quality_tests(T*)
 {
     typedef boost::hash_detail::limits<T> limits;
 
-    BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<T> x2;
+    HASH_NAMESPACE::hash<T> x1;
+    HASH_NAMESPACE::hash<T> x2;
 
     // A hash function can legally fail these tests, but it'll not be a good
     // sign.
@@ -136,8 +123,8 @@ void poor_quality_tests(T*)
 
 void bool_test()
 {
-    BOOST_HASH_TEST_NAMESPACE::hash<bool> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<bool> x2;
+    HASH_NAMESPACE::hash<bool> x1;
+    HASH_NAMESPACE::hash<bool> x2;
     
     BOOST_TEST(x1(true) == x2(true));
     BOOST_TEST(x1(false) == x2(false));
@@ -175,11 +162,6 @@ int main()
     NUMERIC_TEST_NO_LIMITS(boost::ulong_long_type, ulong_long)
 #endif
 
-#if defined(BOOST_HAS_INT128)
-    NUMERIC_TEST_NO_LIMITS(boost::int128_type, int128)
-    NUMERIC_TEST_NO_LIMITS(boost::uint128_type, uint128)
-#endif
-
     NUMERIC_TEST(float, float)
     NUMERIC_TEST(double, double)
 

test/hash_pointer_test.cpp

@@ -5,14 +5,18 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
 #endif
 
 #include <boost/detail/lightweight_test.hpp>
+
 #include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
 #include "./compile_time.hpp"
 
 void pointer_tests()
@@ -20,8 +24,8 @@ void pointer_tests()
     compile_time_tests((int**) 0);
     compile_time_tests((void**) 0);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<int*> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<int*> x2;
+    HASH_NAMESPACE::hash<int*> x1;
+    HASH_NAMESPACE::hash<int*> x2;
 
     int int1;
     int int2;
@@ -29,9 +33,9 @@ void pointer_tests()
     BOOST_TEST(x1(0) == x2(0));
     BOOST_TEST(x1(&int1) == x2(&int1));
     BOOST_TEST(x1(&int2) == x2(&int2));
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(&int1) == BOOST_HASH_TEST_NAMESPACE::hash_value(&int1));
-    BOOST_TEST(x1(&int2) == BOOST_HASH_TEST_NAMESPACE::hash_value(&int2));
+#if defined(TEST_EXTENSIONS)
+    BOOST_TEST(x1(&int1) == HASH_NAMESPACE::hash_value(&int1));
+    BOOST_TEST(x1(&int2) == HASH_NAMESPACE::hash_value(&int2));
 
     // This isn't specified in Peter's proposal:
     BOOST_TEST(x1(0) == 0);

test/hash_range_test.cpp

@@ -5,20 +5,23 @@
 
 #include "./config.hpp"
 
-#if !defined(BOOST_HASH_TEST_EXTENSIONS)
+#if !defined(TEST_EXTENSIONS)
 
 int main() {}
 
 #else
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
 #endif
 
 #include <boost/detail/lightweight_test.hpp>
+
 #include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
 #include <vector>
 
 void hash_range_tests()
@@ -40,39 +43,39 @@ void hash_range_tests()
     std::vector<int> x;
 
     std::size_t x_seed = 0;
-    BOOST_TEST(x_seed == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
-        == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
-        != BOOST_HASH_TEST_NAMESPACE::hash_range(values1.begin(), values1.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        != HASH_NAMESPACE::hash_range(values1.begin(), values1.end()));
 
     x.push_back(10);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(x_seed, 10);
-    BOOST_TEST(x_seed == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
+    HASH_NAMESPACE::hash_combine(x_seed, 10);
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
-        != BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(values2.begin(), values2.end())
-        == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+        == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
     x.push_back(20);
-    BOOST_HASH_TEST_NAMESPACE::hash_combine(x_seed, 20);
-    BOOST_TEST(x_seed == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
+    HASH_NAMESPACE::hash_combine(x_seed, 20);
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
-        != BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(values2.begin(), values2.end())
-        != BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(values3.begin(), values3.end())
-        == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+        != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
+        == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
     std::size_t seed =
-        BOOST_HASH_TEST_NAMESPACE::hash_range(values3.begin(), values3.end());
-    BOOST_HASH_TEST_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
-    BOOST_HASH_TEST_NAMESPACE::hash_range(seed, x.begin(), x.end());
+        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 ==
-        BOOST_HASH_TEST_NAMESPACE::hash_range(values5.begin(), values5.end()));
+        HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
 }
 
 int main()

test/hash_sequence_test.hpp

@@ -38,16 +38,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         containers[10].push_back(-1);
         containers[10].push_back(1);
 
-        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
+        HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
             BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
             BOOST_TEST(hasher(containers[i2]) ==
-                    BOOST_HASH_TEST_NAMESPACE::hash_value(containers[i2]));
+                    HASH_NAMESPACE::hash_value(containers[i2]));
 
             BOOST_TEST(hasher(containers[i2])
-                    == BOOST_HASH_TEST_NAMESPACE::hash_range(
+                    == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {

test/hash_set_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <set>
 
@@ -31,7 +31,7 @@ using std::multiset;
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     set_tests::set_hash_integer_tests();
     multiset_tests::multiset_hash_integer_tests();
 #endif

test/hash_set_test.hpp

@@ -41,16 +41,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         containers[11].insert(4);
         containers[11].insert(5);
 
-        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
+        HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
             BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
             BOOST_TEST(hasher(containers[i2]) ==
-                    BOOST_HASH_TEST_NAMESPACE::hash_value(containers[i2]));
+                    HASH_NAMESPACE::hash_value(containers[i2]));
 
             BOOST_TEST(hasher(containers[i2])
-                    == BOOST_HASH_TEST_NAMESPACE::hash_range(
+                    == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {

test/hash_std_array_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -16,7 +16,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY)
+#if defined(TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY)
 #define TEST_ARRAY
 #include <array>
 #include <vector>

test/hash_std_smart_ptr_test.cpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
@@ -14,7 +14,7 @@
 #include <boost/detail/lightweight_test.hpp>
 #include "./compile_time.hpp"
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR)
+#if defined(TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR)
 #define TEST_SMART_PTRS
 #include <memory>
 #endif
@@ -26,8 +26,8 @@ void shared_ptr_tests()
     std::shared_ptr<int> x;
     compile_time_tests(&x);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<std::shared_ptr<int> > x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::shared_ptr<int> > x2;
+    HASH_NAMESPACE::hash<std::shared_ptr<int> > x1;
+    HASH_NAMESPACE::hash<std::shared_ptr<int> > x2;
 
     std::shared_ptr<int> ptr1(new int(10));
     std::shared_ptr<int> ptr2;
@@ -39,9 +39,9 @@ void shared_ptr_tests()
     BOOST_TEST(x1(ptr1) != x2(ptr2));
     ptr2 = ptr1;
     BOOST_TEST(x1(ptr1) == x2(ptr2));
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
-    BOOST_TEST(x1(ptr1) == BOOST_HASH_TEST_NAMESPACE::hash_value(ptr2));
+#if defined(TEST_EXTENSIONS)
+    BOOST_TEST(x1(x) == HASH_NAMESPACE::hash_value(x));
+    BOOST_TEST(x1(ptr1) == HASH_NAMESPACE::hash_value(ptr2));
 #endif
 }
 
@@ -50,8 +50,8 @@ void unique_ptr_tests()
     std::unique_ptr<int> x;
     compile_time_tests(&x);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<std::unique_ptr<int> > x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::unique_ptr<int> > x2;
+    HASH_NAMESPACE::hash<std::unique_ptr<int> > x1;
+    HASH_NAMESPACE::hash<std::unique_ptr<int> > x2;
 
     std::unique_ptr<int> ptr1(new int(10));
     std::unique_ptr<int> ptr2;
@@ -62,8 +62,8 @@ void unique_ptr_tests()
     BOOST_TEST(x1(ptr1) == x2(ptr1));
     BOOST_TEST(x1(ptr1) != x2(ptr2));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    BOOST_TEST(x1(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
+#if defined(TEST_EXTENSIONS)
+    BOOST_TEST(x1(x) == HASH_NAMESPACE::hash_value(x));
 #endif
 }
 

test/hash_std_tuple_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -16,7 +16,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#if defined(TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
 #define TEST_TUPLE
 #include <tuple>
 #include <vector>

test/hash_string_test.cpp

@@ -5,36 +5,40 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
 #endif
 
 #include <boost/detail/lightweight_test.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
 #include <string>
+
 #include "./compile_time.hpp"
 
 void string_tests()
 {
     compile_time_tests((std::string*) 0);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<std::string> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::string> x2;
+    HASH_NAMESPACE::hash<std::string> x1;
+    HASH_NAMESPACE::hash<std::string> x2;
 
     BOOST_TEST(x1("Hello") == x2(std::string("Hel") + "lo"));
     BOOST_TEST(x1("") == x2(std::string()));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
     std::string value1;
     std::string value2("Hello");
 
-    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
-    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
+    BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value1) ==
+            HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
+            HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
 
@@ -43,22 +47,22 @@ void wstring_tests()
 {
     compile_time_tests((std::wstring*) 0);
 
-    BOOST_HASH_TEST_NAMESPACE::hash<std::wstring> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::wstring> x2;
+    HASH_NAMESPACE::hash<std::wstring> x1;
+    HASH_NAMESPACE::hash<std::wstring> x2;
 
     BOOST_TEST(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
     BOOST_TEST(x1(L"") == x2(std::wstring()));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
     std::wstring value1;
     std::wstring value2(L"Hello");
 
-    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
-    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
+    BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value1) ==
+            HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
+            HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
 #endif

test/hash_type_index_test.cpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_STD_INCLUDES
 #  include <functional>
 #else
 #  include <boost/functional/hash.hpp>
@@ -18,7 +18,7 @@
 #include <typeindex>
 
 void test_type_index() {
-    BOOST_HASH_TEST_NAMESPACE::hash<std::type_index> hasher;
+    HASH_NAMESPACE::hash<std::type_index> hasher;
 
 #if defined(BOOST_NO_TYPEID)
     std::cout<<"Unable to test std::type_index, as typeid isn't available"
@@ -31,9 +31,9 @@ void test_type_index() {
     BOOST_TEST(hasher(int_index) == int_index.hash_code());
     BOOST_TEST(hasher(int_index) == int2_index.hash_code());
     BOOST_TEST(hasher(char_index) == char_index.hash_code());
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(int_index) == int_index.hash_code());
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(int_index) == int2_index.hash_code());
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(char_index) == char_index.hash_code());
+    BOOST_TEST(HASH_NAMESPACE::hash_value(int_index) == int_index.hash_code());
+    BOOST_TEST(HASH_NAMESPACE::hash_value(int_index) == int2_index.hash_code());
+    BOOST_TEST(HASH_NAMESPACE::hash_value(char_index) == char_index.hash_code());
 
     BOOST_TEST(hasher(int_index) == hasher(int2_index));
     BOOST_TEST(hasher(int_index) != hasher(char_index));

test/hash_value_array_test.cpp

@@ -8,8 +8,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -18,7 +18,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 void array_int_test()
 {
@@ -29,32 +29,32 @@ void array_int_test()
         8, -12, 23, 65, 45,
         -1, 93, -54, 987, 3
     };
-    BOOST_HASH_TEST_NAMESPACE::hash<int[25]> hasher1;
+    HASH_NAMESPACE::hash<int[25]> hasher1;
 
     int array2[1] = {3};
-    BOOST_HASH_TEST_NAMESPACE::hash<int[1]> hasher2;
+    HASH_NAMESPACE::hash<int[1]> hasher2;
 
     int array3[2] = {2, 3};
-    BOOST_HASH_TEST_NAMESPACE::hash<int[2]> hasher3;
+    HASH_NAMESPACE::hash<int[2]> hasher3;
 
-    BOOST_TEST(hasher1(array1) == BOOST_HASH_TEST_NAMESPACE::hash_value(array1));
-    BOOST_TEST(hasher2(array2) == BOOST_HASH_TEST_NAMESPACE::hash_value(array2));
-    BOOST_TEST(hasher3(array3) == BOOST_HASH_TEST_NAMESPACE::hash_value(array3));
+    BOOST_TEST(hasher1(array1) == HASH_NAMESPACE::hash_value(array1));
+    BOOST_TEST(hasher2(array2) == HASH_NAMESPACE::hash_value(array2));
+    BOOST_TEST(hasher3(array3) == HASH_NAMESPACE::hash_value(array3));
 }
 
 void two_dimensional_array_test()
 {
     int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
-    BOOST_HASH_TEST_NAMESPACE::hash<int[3][2]> hasher;
+    HASH_NAMESPACE::hash<int[3][2]> hasher;
 
-    BOOST_TEST(hasher(array) == BOOST_HASH_TEST_NAMESPACE::hash_value(array));
+    BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_value(array));
 }
 
 #endif
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     array_int_test();
     two_dimensional_array_test();
 #endif

test/hash_vector_test.cpp

@@ -5,8 +5,8 @@
 
 #include "./config.hpp"
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
-#  ifdef BOOST_HASH_TEST_STD_INCLUDES
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
 #    include <functional>
 #  else
 #    include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
 
 #include <vector>
 
@@ -23,11 +23,11 @@ using std::vector;
 #define CONTAINER_TYPE vector
 #include "./hash_sequence_test.hpp"
 
-#endif // BOOST_HASH_TEST_EXTENSIONS
+#endif // TEST_EXTENSIONS
 
 int main()
 {
-#ifdef BOOST_HASH_TEST_EXTENSIONS
+#ifdef TEST_EXTENSIONS
     vector_tests::vector_hash_integer_tests();
 #endif
 

test/link_ext_test.cpp

@@ -5,24 +5,24 @@
 
 #include "./config.hpp"
 
-#define BOOST_HASH_TEST_NAMESPACE boost
+#define HASH_NAMESPACE boost
 #include <boost/functional/hash.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <vector>
 
 int f(std::size_t hash1, int* x1) {
 
-    // Check that BOOST_HASH_TEST_NAMESPACE::hash<int*> works in both files.
-    BOOST_HASH_TEST_NAMESPACE::hash<int*> ptr_hasher;
+    // Check that HASH_NAMESPACE::hash<int*> works in both files.
+    HASH_NAMESPACE::hash<int*> ptr_hasher;
     BOOST_TEST(hash1 == ptr_hasher(x1));
 
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
+#if defined(TEST_EXTENSIONS)
 
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;
     x.push_back(*x1);
-    BOOST_HASH_TEST_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
-    return vector_hasher(x) != BOOST_HASH_TEST_NAMESPACE::hash_value(x);
+    HASH_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
+    return vector_hasher(x) != HASH_NAMESPACE::hash_value(x);
     
 #else
 

test/link_no_ext_test.cpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#define BOOST_HASH_TEST_NAMESPACE boost
+#define HASH_NAMESPACE boost
 #define BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>
 #include <boost/detail/lightweight_test.hpp>
@@ -13,7 +13,7 @@
 extern int f(std::size_t, int*);
 
 int main() {
-    BOOST_HASH_TEST_NAMESPACE::hash<int*> ptr_hasher;
+    HASH_NAMESPACE::hash<int*> ptr_hasher;
     int x = 55;
     BOOST_TEST(!f(ptr_hasher(&x), &x));
     return boost::report_errors();