Merge branch 'develop'

Hash changelog entry
2026-03-07 14:34:11 +01:00 · 2017-01-01 18:25:51 +00:00 · 2017-01-01 16:04:24 +00:00 · 2017-01-01 16:03:48 +00:00 · 2016-12-05 23:01:20 +00:00 · 2016-12-05 23:00:20 +00:00
22 changed files with 277 additions and 67 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,42 @@
+# Copyright (C) 2016 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)
+
+# Use Trusty to get a reasonably recent version of Boost.
+sudo: required
+dist: trusty
+
+language: c++
+
+addons:
+    apt:
+        packages:
+            - libboost-dev
+            - libboost-tools-dev
+
+matrix:
+    include:
+      - compiler: gcc
+        env: BJAM_TOOLSET=gcc-std03
+      - compiler: gcc
+        env: BJAM_TOOLSET=gcc-std11
+      - compiler: clang
+        env: BJAM_TOOLSET=clang-std03
+      - compiler: clang
+        env: BJAM_TOOLSET=clang-std11
+      - compiler: clang
+        env: BJAM_TOOLSET=clang-pretend_no_auto_ptr_etc
+
+before_script:
+    - |
+        echo "using gcc : std03 : g++-4.8 -Werror --std=c++03 ;" > ~/user-config.jam
+        echo "using gcc : std11 : g++-4.8 -Werror --std=c++11 ;" >> ~/user-config.jam
+        echo "using clang : std03 : clang++ -Werror --std=c++03 ;" >> ~/user-config.jam
+        echo "using clang : std11 : clang++ -Werror --std=c++11 ;" >> ~/user-config.jam
+        echo "using clang : pretend_no_auto_ptr_etc : clang++ -Werror --std=c++11 -D_HAS_AUTO_PTR_ETC=0 ;" >> ~/user-config.jam
+    - cat ~/user-config.jam
+    - touch Jamroot.jam
+
+script:
+    - cd ${TRAVIS_BUILD_DIR}/test
+    - bjam -q ${BJAM_TOOLSET} include=${TRAVIS_BUILD_DIR}/include
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -168,5 +168,27 @@
  ([ticket 8822]).
 * Suppress Visual C++ infinite loop warning ([ticket 8568]).

+[h2 Boost 1.56.0]
+
+* Removed some Visual C++ 6 workarounds.
+* Ongoing work on improving `hash_combine`. This changes the combine function
+  which was previously defined in the reference documentation.
+
+[h2 Boost 1.58.0]
+
+* Fixed strict aliasing violation
+  ([@https://github.com/boostorg/functional/pull/3 GitHub #3]).
+
+[h2 Boost 1.63.0]
+
+* Fixed some warnings.
+* Only define hash for `std::wstring` when we know we have a `wchar_t`.
+  Otherwise there's a compile error as there's no overload for hashing
+  the characters in wide strings ([ticket 8552]).
+
+[h2 Boost 1.64.0]
+
+* Fix for recent versions of Visual C++ which have removed `std::unary_function`
+  and `std::binary_function`.

 [endsect]
--- a/doc/ref.xml
+++ b/doc/ref.xml
@@ -59,6 +59,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              Forward declared in
              <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
            </para>
+            <para>
+              This hash function is not intended for general use, and isn't
+              guaranteed to be equal during separate runs of a program - so
+              please don't use it for any persistent storage or communication.
+            </para>
          </notes>
          <throws><para>
            Only throws if
@@ -450,7 +455,15 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
            Called repeatedly to incrementally create a hash value from
            several variables.
        </simpara></purpose>
-        <effects><programlisting>seed ^= <functionname>hash_value</functionname>(v) + 0x9e3779b9 + (seed &lt;&lt; 6) + (seed &gt;&gt; 2);</programlisting></effects>
+        <effects>
+            Updates <code>seed</code> with a new hash value generated by
+            combining it with the result of
+            <code><functionname>hash_value</functionname>(v)</code>. Will
+            always produce the same result for the same combination of
+            <code>seed</code> and
+            <code><functionname>hash_value</functionname>(v)</code> during
+            the single run of a program.
+        </effects>
        <notes>
          <para><functionname>hash_value</functionname> is called without
          qualification, so that overloads can be found via ADL.</para>
@@ -459,6 +472,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
            Forward declared in
            <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
          </para>
+          <para>
+            This hash function is not intended for general use, and isn't
+            guaranteed to be equal during separate runs of a program - so
+            please don't use it for any persistent storage or communication.
+          </para>
        </notes>
        <throws>
          Only throws if <functionname>hash_value</functionname>(T) throws.
@@ -527,6 +545,11 @@ for(; first != last; ++first)
            Forward declared in
            <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
          </para>
+          <para>
+            This hash function is not intended for general use, and isn't
+            guaranteed to be equal during separate runs of a program - so
+            please don't use it for any persistent storage or communication.
+          </para>
        </notes>
        <throws><para>
          Only throws if <code><functionname>hash_value</functionname>(std::iterator_traits&lt;It&gt;::value_type)</code>
@@ -784,6 +807,11 @@ for(; first != last; ++first)

        <notes>
          <para>This is an extension to TR1</para>
+          <para>
+            This hash function is not intended for general use, and isn't
+            guaranteed to be equal during separate runs of a program - so
+            please don't use it for any persistent storage or communication.
+          </para>
        </notes>

        <throws>
--- a/examples/point.cpp
+++ b/examples/point.cpp
@@ -3,6 +3,11 @@
 // 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)

+// Force use of assert.
+#if defined(NDEBUG)
+#undef NDEBUG
+#endif
+
 #include <boost/functional/hash.hpp>
 #include <cassert>

--- a/examples/portable.cpp
+++ b/examples/portable.cpp
@@ -3,6 +3,11 @@
 // 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)

+// Force use of assert.
+#if defined(NDEBUG)
+#undef NDEBUG
+#endif
+
 #include <boost/functional/hash.hpp>
 #include <cassert>

--- a/include/boost/functional/hash/detail/hash_float.hpp
+++ b/include/boost/functional/hash/detail/hash_float.hpp
@@ -68,7 +68,7 @@ namespace boost
            std::size_t seed = 0;

            if (length >= sizeof(std::size_t)) {
-                seed = *(std::size_t*) ptr;
+                std::memcpy(&seed, ptr, sizeof(std::size_t));
                length -= sizeof(std::size_t);
                ptr += sizeof(std::size_t);

@@ -179,7 +179,7 @@ namespace boost
                hash_float_combine(seed, part);
            }

-            hash_float_combine(seed, exp);
+            hash_float_combine(seed, static_cast<std::size_t>(exp));

            return seed;
        }
--- a/include/boost/functional/hash/extensions.hpp
+++ b/include/boost/functional/hash/extensions.hpp
@@ -254,7 +254,7 @@ namespace boost
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

    template <class T> struct hash
-        : std::unary_function<T, std::size_t>
+        : boost::hash_detail::hash_base<T>
    {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
        std::size_t operator()(T const& val) const
@@ -271,7 +271,7 @@ namespace boost

 #if BOOST_WORKAROUND(__DMC__, <= 0x848)
    template <class T, unsigned int n> struct hash<T[n]>
-        : std::unary_function<T[n], std::size_t>
+        : boost::hash_detail::hash_base<T[n]>
    {
        std::size_t operator()(const T* val) const
        {
@@ -296,7 +296,7 @@ namespace boost
        {
            template <class T>
            struct inner
-                : std::unary_function<T, std::size_t>
+                : boost::hash_detail::hash_base<T>
            {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
                std::size_t operator()(T const& val) const
--- a/include/boost/functional/hash/hash.hpp
+++ b/include/boost/functional/hash/hash.hpp
@@ -1,11 +1,17 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-2014 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)

 //  Based on Peter Dimov's proposal
 //  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
 //  issue 6.18. 
+//
+//  This also contains public domain code from MurmurHash. From the
+//  MurmurHash header:
+
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.

 #if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
 #define BOOST_FUNCTIONAL_HASH_HASH_HPP
@@ -18,6 +24,7 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/utility/enable_if.hpp>
+#include <boost/cstdint.hpp>

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 #include <boost/type_traits/is_pointer.hpp>
@@ -45,10 +52,28 @@
 #define BOOST_HASH_CHAR_TRAITS char_traits
 #endif

+#if defined(_MSC_VER)
+#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
 namespace boost
 {
    namespace hash_detail
    {
+#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
+        template <typename T>
+        struct hash_base
+        {
+            typedef T argument_type;
+            typedef std::size_t result_type;
+        };
+#else
+        template <typename T>
+        struct hash_base : std::unary_function<T, std::size_t> {};
+#endif
+
        struct enable_hash_value { typedef std::size_t type; };

        template <typename T> struct basic_numbers {};
@@ -155,10 +180,10 @@ namespace boost
        template <class T>
        inline std::size_t hash_value_signed(T val)
        {
-             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
             const int length = (std::numeric_limits<T>::digits - 1)
-                 / size_t_bits;
+                 / static_cast<int>(size_t_bits);

             std::size_t seed = 0;
             T positive = val < 0 ? -1 - val : val;
@@ -176,10 +201,10 @@ namespace boost
        template <class T>
        inline std::size_t hash_value_unsigned(T val)
        {
-             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
             const int length = (std::numeric_limits<T>::digits - 1)
-                 / size_t_bits;
+                 / static_cast<int>(size_t_bits);

             std::size_t seed = 0;

@@ -192,6 +217,53 @@ namespace boost

             return seed;
        }
+
+        template <typename SizeT>
+        inline void hash_combine_impl(SizeT& seed, SizeT value)
+        {
+            seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+
+        inline void hash_combine_impl(boost::uint32_t& h1,
+                boost::uint32_t k1)
+        {
+            const uint32_t c1 = 0xcc9e2d51;
+            const uint32_t c2 = 0x1b873593;
+
+            k1 *= c1;
+            k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
+            k1 *= c2;
+
+            h1 ^= k1;
+            h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
+            h1 = h1*5+0xe6546b64;
+        }
+
+
+// Don't define 64-bit hash combine on platforms without 64 bit integers,
+// and also not for 32-bit gcc as it warns about the 64-bit constant.
+#if !defined(BOOST_NO_INT64_T) && \
+        !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+
+        inline void hash_combine_impl(boost::uint64_t& h,
+                boost::uint64_t k)
+        {
+            const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+            const int r = 47;
+
+            k *= m;
+            k ^= k >> r;
+            k *= m;
+
+            h ^= k;
+            h *= m;
+
+            // Completely arbitrary number, to prevent 0's
+            // from hashing to 0.
+            h += 0xe6546b64;
+        }
+
+#endif // BOOST_NO_INT64_T
    }

    template <typename T>
@@ -252,7 +324,7 @@ namespace boost
    inline void hash_combine(std::size_t& seed, T const& v)
    {
        boost::hash<T> hasher;
-        seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
    }

 #if defined(BOOST_MSVC)
@@ -353,13 +425,13 @@ namespace boost
    // passed by copy.
    //
    // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
-    // passed by copy.
+    // passed by const reference.
    //
    // These are undefined later.

 #define BOOST_HASH_SPECIALIZE(type) \
    template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
    { \
        std::size_t operator()(type v) const \
        { \
@@ -369,7 +441,7 @@ namespace boost

 #define BOOST_HASH_SPECIALIZE_REF(type) \
    template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
    { \
        std::size_t operator()(type const& v) const \
        { \
@@ -396,7 +468,7 @@ namespace boost
    BOOST_HASH_SPECIALIZE(long double)

    BOOST_HASH_SPECIALIZE_REF(std::string)
-#if !defined(BOOST_NO_STD_WSTRING)
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    BOOST_HASH_SPECIALIZE_REF(std::wstring)
 #endif

@@ -423,7 +495,7 @@ namespace boost

    template <class T>
    struct hash<T*>
-        : public std::unary_function<T*, std::size_t>
+        : public boost::hash_detail::hash_base<T*>
    {
        std::size_t operator()(T* v) const
        {
@@ -456,7 +528,7 @@ namespace boost
        {
            template <class T>
            struct inner
-                : public std::unary_function<T, std::size_t>
+                : public boost::hash_detail::hash_base<T>
            {
                std::size_t operator()(T val) const
                {
@@ -483,6 +555,7 @@ namespace boost
 }

 #undef BOOST_HASH_CHAR_TRAITS
+#undef BOOST_FUNCTIONAL_HASH_ROTL32

 #if defined(BOOST_MSVC)
 #pragma warning(pop)
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -0,0 +1,20 @@
+[
+    {
+        "key": "functional/hash",
+        "boost-version": "1.33.0",
+        "name": "Functional/Hash",
+        "authors": [
+            "Daniel James"
+        ],
+        "maintainers": [
+            "Daniel James <dnljms -at- gmail.com>"
+        ],
+        "description": "A TR1 hash function object that can be extended to hash user defined types.",
+        "std": [
+            "tr1"
+        ],
+        "category": [
+            "Function-objects"
+        ]
+    }
+]
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -12,6 +12,7 @@ project hash-tests
        #<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>clang:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wsign-conversion -Wconversion -Wfloat-equal -Wshadow"
        #<toolset>msvc:<warnings-as-errors>on
        #<toolset>gcc:<warnings-as-errors>on
        #<toolset>darwin:<warnings-as-errors>on
@@ -19,6 +20,7 @@ project hash-tests

 test-suite functional/hash
    :
+        [ compile check_float_funcs.cpp ]
        [ run hash_fwd_test_1.cpp ]
        [ run hash_fwd_test_2.cpp ]
        [ run hash_number_test.cpp ]
--- a/test/extra/check_float_funcs.cpp
+++ b/test/extra/check_float_funcs.cpp
--- a/test/compile_time.hpp
+++ b/test/compile_time.hpp
@@ -10,7 +10,9 @@
 template <class T>
 void compile_time_tests(T*)
 {
+#if !defined(_HAS_AUTO_PTR_ETC) || _HAS_AUTO_PTR_ETC
    BOOST_STATIC_ASSERT((boost::is_base_and_derived<
        std::unary_function<T, std::size_t>, BOOST_HASH_TEST_NAMESPACE::hash<T> >::value));
+#endif
 }

--- a/test/extra/Jamfile.v2
+++ b/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 ]
-    ;
--- a/test/hash_complex_test.cpp
+++ b/test/hash_complex_test.cpp
@@ -84,8 +84,8 @@ void complex_integral_tests(Integer*)
    generic_complex_tests(complex(15342,124));
    generic_complex_tests(complex(25,54356));
    generic_complex_tests(complex(5325,2346));
-    generic_complex_tests(complex(-243897,-49923874));
-    generic_complex_tests(complex(-543,763));
+    generic_complex_tests(complex(Integer(-243897),Integer(-49923874)));
+    generic_complex_tests(complex(Integer(-543),Integer(763)));
 }

 int main()
--- a/test/hash_custom_test.cpp
+++ b/test/hash_custom_test.cpp
@@ -15,7 +15,7 @@ namespace test

        std::size_t hash() const
        {
-            return value_ * 10;
+            return static_cast<std::size_t>(value_ * 10);
        }

 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
--- a/test/hash_friend_test.cpp
+++ b/test/hash_friend_test.cpp
@@ -17,7 +17,7 @@ namespace test

        std::size_t hash() const
        {
-            return value_ * 10;
+            return static_cast<std::size_t>(value_ * 10);
        }

 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
--- a/test/hash_global_namespace_test.cpp
+++ b/test/hash_global_namespace_test.cpp
@@ -17,7 +17,7 @@ struct custom

    std::size_t hash() const
    {
-        return value_ * 10;
+        return static_cast<std::size_t>(value_ * 10);
    }

 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
--- a/test/hash_number_test.cpp
+++ b/test/hash_number_test.cpp
@@ -58,8 +58,6 @@ void numeric_extra_tests(typename
 template <class T>
 void numeric_test(T*)
 {
-    typedef boost::hash_detail::limits<T> limits;
-
    compile_time_tests((T*) 0);

    BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
@@ -129,9 +127,13 @@ void poor_quality_tests(T*)
        BOOST_TEST(x1(T(1)) !=  x2(T(-1)));
    if(T(1) != T(2))
        BOOST_TEST(x1(T(1)) !=  x2(T(2)));
-    if((limits::max)() != (limits::max)() - 1)
-        BOOST_TEST(x1(static_cast<T>((limits::max)()))
-            != x2(static_cast<T>((limits::max)() - 1)));
+
+    // TODO: This test is useless for floating point numbers.
+    T max_number = static_cast<T>((limits::max)());
+    T max_minus_one = static_cast<T>(max_number - 1);
+    if (max_number != max_minus_one) {
+        BOOST_TEST(x1(max_number) != x1(max_minus_one));
+    }
 }

 void bool_test()
--- a/test/hash_sequence_test.hpp
+++ b/test/hash_sequence_test.hpp
@@ -19,6 +19,8 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
    template <class T>
    void integer_tests(T* = 0)
    {
+        typedef typename T::value_type value_type;
+
        const int number_of_containers = 11;
        T containers[number_of_containers];

@@ -27,16 +29,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
                containers[i].push_back(0);
        }

-        containers[5].push_back(1);
-        containers[6].push_back(1);
-        containers[6].push_back(1);
-        containers[7].push_back(-1);
-        containers[8].push_back(-1);
-        containers[8].push_back(-1);
-        containers[9].push_back(1);
-        containers[9].push_back(-1);
-        containers[10].push_back(-1);
-        containers[10].push_back(1);
+        containers[5].push_back(value_type(1));
+        containers[6].push_back(value_type(1));
+        containers[6].push_back(value_type(1));
+        containers[7].push_back(value_type(-1));
+        containers[8].push_back(value_type(-1));
+        containers[8].push_back(value_type(-1));
+        containers[9].push_back(value_type(1));
+        containers[9].push_back(value_type(-1));
+        containers[10].push_back(value_type(-1));
+        containers[10].push_back(value_type(1));

        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;

--- a/test/hash_set_test.hpp
+++ b/test/hash_set_test.hpp
@@ -19,6 +19,8 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
    template <class T>
    void integer_tests(T* = 0)
    {
+        typedef typename T::value_type value_type;
+
        const int number_of_containers = 12;
        T containers[number_of_containers];

@@ -27,19 +29,19 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
                containers[i].insert(0);
        }

-        containers[6].insert(1);
-        containers[7].insert(1);
-        containers[7].insert(1);
-        containers[8].insert(-1);
-        containers[9].insert(-1);
-        containers[9].insert(-1);
-        containers[10].insert(-1);
-        containers[10].insert(1);
-        containers[11].insert(1);
-        containers[11].insert(2);
-        containers[11].insert(3);
-        containers[11].insert(4);
-        containers[11].insert(5);
+        containers[6].insert(value_type(1));
+        containers[7].insert(value_type(1));
+        containers[7].insert(value_type(1));
+        containers[8].insert(value_type(-1));
+        containers[9].insert(value_type(-1));
+        containers[9].insert(value_type(-1));
+        containers[10].insert(value_type(-1));
+        containers[10].insert(value_type(1));
+        containers[11].insert(value_type(1));
+        containers[11].insert(value_type(2));
+        containers[11].insert(value_type(3));
+        containers[11].insert(value_type(4));
+        containers[11].insert(value_type(5));

        BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;

--- a/test/hash_string_test.cpp
+++ b/test/hash_string_test.cpp
@@ -38,7 +38,24 @@ void string_tests()
 #endif
 }

-#if !defined(BOOST_NO_STD_WSTRING)
+void string0_tests()
+{
+    std::string x1(1, '\0');
+    std::string x2(2, '\0');
+    std::string x3(3, '\0');
+    std::string x4(10, '\0');
+
+    BOOST_HASH_TEST_NAMESPACE::hash<std::string> hasher;
+
+    BOOST_TEST(hasher(x1) != hasher(x2));
+    BOOST_TEST(hasher(x1) != hasher(x3));
+    BOOST_TEST(hasher(x1) != hasher(x4));
+    BOOST_TEST(hasher(x2) != hasher(x3));
+    BOOST_TEST(hasher(x2) != hasher(x4));
+    BOOST_TEST(hasher(x3) != hasher(x4));
+}
+
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
 void wstring_tests()
 {
    compile_time_tests((std::wstring*) 0);
@@ -66,7 +83,8 @@ void wstring_tests()
 int main()
 {
    string_tests();
-#if !defined(BOOST_NO_STD_WSTRING)
+    string0_tests();
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    wstring_tests();
 #endif
    return boost::report_errors();
--- a/test/link_ext_test.cpp
+++ b/test/link_ext_test.cpp
@@ -20,7 +20,7 @@ int f(std::size_t hash1, int* x1) {

    // Check that std::vector<std::size_t> is avaiable in this file.
    std::vector<std::size_t> x;
-    x.push_back(*x1);
+    x.push_back(static_cast<std::size_t>(*x1));
    BOOST_HASH_TEST_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
    return vector_hasher(x) != BOOST_HASH_TEST_NAMESPACE::hash_value(x);