Merge branch 'develop' into feature/reference

This reverts commit cab5c6c8d7.

.appveyor.yml

@@ -1,4 +1,5 @@
 # Copyright 2017 Daniel James
+# Copyright 2016-2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
@@ -6,31 +7,66 @@ version: 1.0.{build}-{branch}
 
 shallow_clone: true
 
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
+      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0,msvc-14.0
+      ADDRMD: 32,64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: msvc-14.1
       CXXSTD: 14,17
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: msvc-14.2
+      CXXSTD: 14,17,latest
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: clang-win
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
 
 install:
-  - cd c:\projects
-  - curl -sSL -o boost.7z https://dl.bintray.com/boostorg/release/1.67.0/source/boost_1_67_0.7z
-  - 7z x boost.7z
-  - set BOOST_ROOT=c:\projects\boost_1_67_0
-  - rd /s /q %BOOST_ROOT%\boost\functional\hash
-  - cd %BOOST_ROOT%\tools\build
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\container_hash\
+  - python tools/boostdep/depinst/depinst.py -I examples container_hash
   - cmd /c bootstrap
-  - cd %APPVEYOR_BUILD_FOLDER%
-  - echo. 2>Jamroot.jam
+  - b2 -d0 headers
 
 build: off
 
 test_script:
+  - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - cd %APPVEYOR_BUILD_FOLDER%\test
-  - cmd /c %BOOST_ROOT%\tools\build\b2 -j 3 toolset=%TOOLSET% %CXXSTD% include=%APPVEYOR_BUILD_FOLDER%\include include=%BOOST_ROOT% --verbose-test hash_info
-  - cmd /c %BOOST_ROOT%\tools\build\b2 -j 3 toolset=%TOOLSET% %CXXSTD% include=%APPVEYOR_BUILD_FOLDER%\include include=%BOOST_ROOT%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j3 --verbose-test libs/container_hash/test//hash_info toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+  - b2 -j3 libs/container_hash/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

.github/workflows/ci.yml

@@ -0,0 +1,204 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.8
+            cxxstd: "03,11"
+            os: ubuntu-18.04
+            install: g++-4.8-multilib
+            address-model: 32,64
+          - toolset: gcc-5
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: g++-5-multilib
+            address-model: 32,64
+          - toolset: gcc-6
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: g++-6-multilib
+            address-model: 32,64
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: g++-7-multilib
+            address-model: 32,64
+          - toolset: gcc-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            install: g++-8-multilib
+            address-model: 32,64
+          - toolset: gcc-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-9-multilib
+            address-model: 32,64
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10-multilib
+            address-model: 32,64
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install: g++-11-multilib
+            address-model: 32,64
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py -I examples --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          export ADDRMD=${{matrix.address-model}}
+          ./b2 -j3 --verbose-test libs/$LIBRARY/test//hash_info toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.1
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2016
+          - toolset: msvc-14.2
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: gcc
+            cxxstd: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py -I examples --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 --verbose-test libs/%LIBRARY%/test//hash_info toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release

CMakeLists.txt

@@ -2,8 +2,8 @@
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.5)
-project(BoostContainerHash LANGUAGES CXX)
+cmake_minimum_required(VERSION 3.5...3.20)
+project(boost_container_hash VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
 add_library(boost_container_hash INTERFACE)
 add_library(Boost::container_hash ALIAS boost_container_hash)
@@ -20,4 +20,3 @@ target_link_libraries(boost_container_hash
         Boost::static_assert
         Boost::type_traits
 )
-

include/boost/container_hash/hash.hpp

@@ -26,6 +26,7 @@
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/core/enable_if.hpp>
 #include <boost/cstdint.hpp>
+#include <climits>
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 #include <boost/type_traits/is_pointer.hpp>
@@ -307,52 +308,56 @@ namespace boost
              return seed;
         }
 
-        template <typename SizeT>
-        inline void hash_combine_impl(SizeT& seed, SizeT value)
+        template<std::size_t Bits> struct hash_combine_impl
         {
-            seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
-        }
+            template <typename SizeT>
+            inline static SizeT fn(SizeT seed, SizeT value)
+            {
+                seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+                return seed;
+            }
+        };
 
-        inline void hash_combine_impl(boost::uint32_t& h1,
-                boost::uint32_t k1)
+        template<> struct hash_combine_impl<32>
         {
-            const uint32_t c1 = 0xcc9e2d51;
-            const uint32_t c2 = 0x1b873593;
+            inline static boost::uint32_t fn(boost::uint32_t h1, boost::uint32_t k1)
+            {
+                const boost::uint32_t c1 = 0xcc9e2d51;
+                const boost::uint32_t c2 = 0x1b873593;
 
-            k1 *= c1;
-            k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
-            k1 *= c2;
+                k1 *= c1;
+                k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
+                k1 *= c2;
 
-            h1 ^= k1;
-            h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
-            h1 = h1*5+0xe6546b64;
-        }
+                h1 ^= k1;
+                h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
+                h1 = h1*5+0xe6546b64;
 
+                return h1;
+            }
+        };
 
-// 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)
+        template<> struct hash_combine_impl<64>
         {
-            const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
-            const int r = 47;
+            inline static boost::uint64_t fn(boost::uint64_t h, boost::uint64_t k)
+            {
+                const boost::uint64_t m = (boost::uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
+                const int r = 47;
 
-            k *= m;
-            k ^= k >> r;
-            k *= m;
+                k *= m;
+                k ^= k >> r;
+                k *= m;
 
-            h ^= k;
-            h *= m;
+                h ^= k;
+                h *= m;
 
-            // Completely arbitrary number, to prevent 0's
-            // from hashing to 0.
-            h += 0xe6546b64;
-        }
+                // Completely arbitrary number, to prevent 0's
+                // from hashing to 0.
+                h += 0xe6546b64;
 
-#endif // BOOST_NO_INT64_T
+                return h;
+            }
+        };
     }
 
     template <typename T>
@@ -413,7 +418,7 @@ namespace boost
     inline void hash_combine(std::size_t& seed, T const& v)
     {
         boost::hash<T> hasher;
-        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
+        seed = boost::hash_detail::hash_combine_impl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, hasher(v));
     }
 
 #if defined(BOOST_MSVC)

meta/libraries.json

@@ -1,6 +1,6 @@
 [
     {
-        "key": "functional/hash",
+        "key": "container_hash",
         "boost-version": "1.33.0",
         "name": "Container Hash",
         "authors": [
@@ -15,6 +15,7 @@
         ],
         "category": [
             "Function-objects"
-        ]
+        ],
+        "cxxstd": "03"
     }
 ]

test/Jamfile.v2

@@ -7,15 +7,14 @@ import testing ;
 
 project hash-tests
     : requirements
-        <warnings>all
+        <warnings>pedantic
         <toolset>intel:<warnings>on
-        #<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
+        <toolset>gcc:<cxxflags>"-Wstrict-aliasing -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>darwin:<cxxflags>"-Wstrict-aliasing -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>clang:<cxxflags>"-Wstrict-aliasing -Wsign-promo -Wunused-parameter -Wsign-conversion -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>msvc:<warnings-as-errors>on
+        <toolset>gcc:<warnings-as-errors>on
+        <toolset>clang:<warnings-as-errors>on
     ;
 
 test-suite container_hash/hash
@@ -85,3 +84,5 @@ test-suite container_hash/hash_no_generic_float
 explicit container_hash/hash_no_generic_float ;
 
 build-project ../examples ;
+
+run hash_reference_values.cpp ;

test/check_float_funcs.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)
 
+#if defined(__GNUC__)
+// in type_traits/is_complete.hpp:47
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>

test/hash_complex_test.cpp

@@ -35,7 +35,7 @@ int main() {}
 #endif
 #endif
 
-#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
+#if ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_INTEL_CXX_VERSION)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 

test/hash_float_test.hpp

@@ -30,7 +30,7 @@
 #endif
 #endif
 
-#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
+#if ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_INTEL_CXX_VERSION)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 

test/hash_number_test.cpp

@@ -26,7 +26,7 @@
 #pragma warning(disable:4310) // cast truncates constant value
 #endif
 
-#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
+#if ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_INTEL_CXX_VERSION)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 

test/hash_reference_values.cpp

@@ -0,0 +1,495 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config/pragma_message.hpp>
+
+#if defined(__GNUC__) && !defined(__clang__) && __cplusplus < 201100L
+
+BOOST_PRAGMA_MESSAGE("Skipping test under GCC in C++98 mode")
+int main() {}
+
+#else
+
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wlong-long"
+#endif
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+#include <vector>
+#include <list>
+#include <utility>
+#include <complex>
+#include <limits>
+#include <climits>
+#include <cfloat>
+#include <cstddef>
+
+// This test checks whether hash values have changed
+
+template<class T> std::size_t hv( T const& t )
+{
+    return boost::hash<T>()( t );
+}
+
+int main()
+{
+    // char
+    BOOST_TEST_EQ( hv('\x00'), 0 );
+    BOOST_TEST_EQ( hv('A'), 'A' );
+    BOOST_TEST_EQ( hv('\x7F'), 0x7F );
+
+    // signed char
+    BOOST_TEST_EQ( hv((signed char)0), 0 );
+    BOOST_TEST_EQ( hv((signed char)+1), +1 );
+    BOOST_TEST_EQ( hv((signed char)-1), (std::size_t)-1 );
+    BOOST_TEST_EQ( hv((signed char)+127), 127 );
+    BOOST_TEST_EQ( hv((signed char)-128), (std::size_t)-128 );
+
+    // unsigned char
+    BOOST_TEST_EQ( hv((unsigned char)0), 0 );
+    BOOST_TEST_EQ( hv((unsigned char)1), 1 );
+    BOOST_TEST_EQ( hv((unsigned char)255), 255 );
+
+    // short
+    BOOST_TEST_EQ( hv((short)0), 0 );
+    BOOST_TEST_EQ( hv((short)+1), 1 );
+    BOOST_TEST_EQ( hv((short)-1), (std::size_t)-1 );
+    BOOST_TEST_EQ( hv((short)+32767), 32767 );
+    BOOST_TEST_EQ( hv((short)-32768), (std::size_t)-32768 );
+
+    // unsigned short
+    BOOST_TEST_EQ( hv((unsigned short)0), 0 );
+    BOOST_TEST_EQ( hv((unsigned short)1), 1 );
+    BOOST_TEST_EQ( hv((unsigned short)65535), 65535 );
+
+    // int
+    BOOST_TEST_EQ( hv(0), 0 );
+    BOOST_TEST_EQ( hv(+1), 1 );
+    BOOST_TEST_EQ( hv(-1), (std::size_t)-1 );
+    BOOST_TEST_EQ( hv(+32767), 32767 );
+    BOOST_TEST_EQ( hv(-32768), (std::size_t)-32768 );
+
+    // unsigned int
+    BOOST_TEST_EQ( hv((unsigned)0), 0 );
+    BOOST_TEST_EQ( hv((unsigned)1), 1 );
+    BOOST_TEST_EQ( hv((unsigned)65535), 65535 );
+    BOOST_TEST_EQ( hv((unsigned)-1), (std::size_t)(unsigned)-1 );
+
+    // long
+    BOOST_TEST_EQ( hv(0L), 0 );
+    BOOST_TEST_EQ( hv(+1L), 1 );
+    BOOST_TEST_EQ( hv(-1L), (std::size_t)-1 );
+    BOOST_TEST_EQ( hv(+32767L), 32767 );
+    BOOST_TEST_EQ( hv(-32768L), (std::size_t)-32768 );
+
+    // unsigned long
+    BOOST_TEST_EQ( hv(0UL), 0 );
+    BOOST_TEST_EQ( hv(1UL), 1 );
+    BOOST_TEST_EQ( hv(65535UL), 65535 );
+    BOOST_TEST_EQ( hv((unsigned long)-1), (std::size_t)(unsigned long)-1 );
+
+    // long long
+    BOOST_TEST_EQ( hv(0LL), 0 );
+    BOOST_TEST_EQ( hv(+1LL), 1 );
+    BOOST_TEST_EQ( hv(-1LL), (std::size_t)-1 );
+    BOOST_TEST_EQ( hv(+32767LL), 32767 );
+    BOOST_TEST_EQ( hv(-32768LL), (std::size_t)-32768 );
+
+    // unsigned long long
+    BOOST_TEST_EQ( hv(0ULL), 0 );
+    BOOST_TEST_EQ( hv(1ULL), 1 );
+    BOOST_TEST_EQ( hv(65535ULL), 65535 );
+#if SIZE_MAX == 4294967295U
+    BOOST_TEST_EQ( hv((unsigned long long)-1), 3221225537U );
+#else
+    BOOST_TEST_EQ( hv((unsigned long long)-1), (std::size_t)-1 );
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+    typedef boost::int128_type int128;
+
+    BOOST_TEST_EQ( hv((int128)0), 0 );
+    BOOST_TEST_EQ( hv((int128)1), 1 );
+    BOOST_TEST_EQ( hv((int128)-1), (std::size_t)-1 );
+    BOOST_TEST_EQ( hv((int128)+32767), 32767 );
+    BOOST_TEST_EQ( hv((int128)-32768), (std::size_t)-32768 );
+
+    typedef boost::uint128_type uint128;
+
+    BOOST_TEST_EQ( hv((uint128)0), 0 );
+    BOOST_TEST_EQ( hv((uint128)1), 1 );
+    BOOST_TEST_EQ( hv((uint128)65535), 65535 );
+
+#if defined(BOOST_GCC) && BOOST_GCC < 100000
+
+    // This looks like some sort of miscompilation.
+    // Under CI, both GHA and Appveyor GCCs produce this value.
+    // But the exact same test on godbolt.org produces the correct
+    // value, below.
+
+    // BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
+
+#else
+
+    BOOST_TEST_EQ( hv((uint128)-1), 13835058055282163777ULL );
+
+#endif
+
+#endif
+
+    // float
+    BOOST_TEST_EQ( hv(0.0f), 0 );
+    BOOST_TEST_EQ( hv(-0.0f), 0 );
+    BOOST_TEST_EQ( hv(1.0f), 1065353216U );
+    BOOST_TEST_EQ( hv(-1.0f), 3212836864U );
+    BOOST_TEST_EQ( hv(3.14f), 1078523331U );
+    BOOST_TEST_EQ( hv(-3.14f), 3226006979U );
+    BOOST_TEST_EQ( hv(1e-38f), 7136238U );
+    BOOST_TEST_EQ( hv(-1e-38f), 2154619886U );
+    BOOST_TEST_EQ( hv(1e+38f), 2123789977U );
+    BOOST_TEST_EQ( hv(-1e+38f), 4271273625U );
+
+#if !defined(__GLIBCXX__)
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 2139095040U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 4286578688U );
+
+#elif SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 4294967295U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 4294967294U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 18446744073709551614ULL );
+
+#endif
+
+    // double
+    BOOST_TEST_EQ( hv(0.0), 0 );
+    BOOST_TEST_EQ( hv(-0.0), 0 );
+
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(1.0), 1072693248U );
+    BOOST_TEST_EQ( hv(-1.0), 3220176896U );
+    BOOST_TEST_EQ( hv(3.14), 2660156064U );
+    BOOST_TEST_EQ( hv(-3.14), 512672416U );
+    BOOST_TEST_EQ( hv(1e-308), 1553872728U );
+    BOOST_TEST_EQ( hv(-1e-308), 3701356376U );
+    BOOST_TEST_EQ( hv(1e+308), 2577739707U );
+    BOOST_TEST_EQ( hv(-1e+308), 430256059U );
+
+#if !defined(__GLIBCXX__)
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 2146435072U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 4293918720U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 4294967295U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 4294967294U );
+
+#endif
+
+#else
+
+    BOOST_TEST_EQ( hv(1.0), 4607182418800017408ULL );
+    BOOST_TEST_EQ( hv(-1.0), 13830554455654793216ULL );
+    BOOST_TEST_EQ( hv(3.14), 4614253070214989087ULL );
+    BOOST_TEST_EQ( hv(-3.14), 13837625107069764895ULL );
+    BOOST_TEST_EQ( hv(1e-308), 2024022533073106ULL );
+    BOOST_TEST_EQ( hv(-1e-308), 9225396059387848914ULL );
+    BOOST_TEST_EQ( hv(1e+308), 9214871658872686752ULL );
+    BOOST_TEST_EQ( hv(-1e+308), 18438243695727462560ULL );
+
+#if !defined(__GLIBCXX__)
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 9218868437227405312ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 18442240474082181120ULL );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 18446744073709551614ULL );
+
+#endif
+
+#endif
+
+    // long double
+    BOOST_TEST_EQ( hv(0.0L), 0 );
+    BOOST_TEST_EQ( hv(-0.0L), 0 );
+
+#if defined(_WIN32) && !defined(__GNUC__) // Under MS ABI, long double == double
+
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(1.0L), 1072693248U );
+    BOOST_TEST_EQ( hv(-1.0L), 3220176896U );
+    BOOST_TEST_EQ( hv(3.14L), 2660156064U );
+    BOOST_TEST_EQ( hv(-3.14L), 512672416U );
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 2146435072U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4293918720U );
+
+#else
+
+    BOOST_TEST_EQ( hv(1.0L), 4607182418800017408ULL );
+    BOOST_TEST_EQ( hv(-1.0L), 13830554455654793216ULL );
+    BOOST_TEST_EQ( hv(3.14L), 4614253070214989087ULL );
+    BOOST_TEST_EQ( hv(-3.14L), 13837625107069764895ULL );
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 9218868437227405312ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18442240474082181120ULL );
+
+#endif
+
+#else
+
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(1.0L), 2684370943U );
+    BOOST_TEST_EQ( hv(-1.0L), 2684403711U );
+    BOOST_TEST_EQ( hv(3.14L), 83002659U );
+    BOOST_TEST_EQ( hv(-3.14L), 82969891U );
+
+#if !defined(__GLIBCXX__)
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 0xA0007FFFu );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 0xA000FFFFu );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 4294967295U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4294967294U );
+
+#endif
+
+#else
+
+    BOOST_TEST_EQ( hv(1.0L), 11529215046068486143ULL );
+    BOOST_TEST_EQ( hv(-1.0L), 11529215046068518911ULL );
+    BOOST_TEST_EQ( hv(3.14L), 12059468778148142067ULL );
+    BOOST_TEST_EQ( hv(-3.14L), 12059468778147191795ULL );
+
+#if !defined(__GLIBCXX__)
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 11529215046068502527ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 11529215046068535295ULL );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18446744073709551614ULL );
+
+#endif
+
+#endif
+
+#endif
+
+    // C array
+    {
+        int a1[] = { 0 };
+        int a2[] = { 0, 0 };
+        int a3[] = { 0, 0, 0 };
+
+#if SIZE_MAX == 4294967295U
+
+        BOOST_TEST_EQ( hv(a1), 3864292196U );
+        BOOST_TEST_EQ( hv(a2), 2842917718U );
+        BOOST_TEST_EQ( hv(a3), 325752138U );
+
+#else
+
+        BOOST_TEST_EQ( hv(a1), 3864292196ULL );
+        BOOST_TEST_EQ( hv(a2), 14642545639667855512ULL );
+        BOOST_TEST_EQ( hv(a3), 17867750819888810972ULL );
+
+#endif
+    }
+
+    // string
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::string()), 0 );
+    BOOST_TEST_EQ( hv(std::string("abc")), 1849538372U );
+    BOOST_TEST_EQ( hv(std::string("\0", 1)), 3864292196U );
+    BOOST_TEST_EQ( hv(std::string("\0\0", 2)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::string("\0\0\0", 3)), 325752138U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::string()), 0 );
+    BOOST_TEST_EQ( hv(std::string("abc")), 6420922261882292859ULL );
+    BOOST_TEST_EQ( hv(std::string("\0", 1)), 3864292196ULL );
+    BOOST_TEST_EQ( hv(std::string("\0\0", 2)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::string("\0\0\0", 3)), 17867750819888810972ULL );
+
+#endif
+
+    // pointer
+    BOOST_TEST_EQ( hv((void*)0), 0 );
+    BOOST_TEST_EQ( hv((void*)0x200014A0), 603985716U );
+
+    // complex<int>
+    BOOST_TEST_EQ( hv(std::complex<int>(0, 0)), 0U );
+    BOOST_TEST_EQ( hv(std::complex<int>(+1, 0)), 1U );
+    BOOST_TEST_EQ( hv(std::complex<int>(0, +1)), 65U );
+
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::complex<int>(-1, 0)), 4294967295U );
+    BOOST_TEST_EQ( hv(std::complex<int>(0, -1)), 3221225536U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::complex<int>(-1, 0)), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(std::complex<int>(0, -1)), 13835058055282163776ULL );
+
+#endif
+
+    // complex<float>
+    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, 0.0f)), 0U );
+    BOOST_TEST_EQ( hv(std::complex<float>(+1.0f, 0.0f)), 1065353216U );
+    BOOST_TEST_EQ( hv(std::complex<float>(-1.0f, 0.0f)), 3212836864U );
+
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, +1.0f)), 3495952384U );
+    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, -1.0f)), 2959081472U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, +1.0f)), 67920461824ULL );
+    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, -1.0f)), 209117511680ULL );
+
+#endif
+
+    // complex<double>
+    BOOST_TEST_EQ( hv(std::complex<double>(0.0, 0.0)), 0U );
+
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::complex<double>(+1.0, 0.0)), 1072693248U );
+    BOOST_TEST_EQ( hv(std::complex<double>(-1.0, 0.0)), 3220176896U );
+    BOOST_TEST_EQ( hv(std::complex<double>(0.0, +1.0)), 873201664U );
+    BOOST_TEST_EQ( hv(std::complex<double>(0.0, -1.0)), 2483814400U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::complex<double>(+1.0, 0.0)), 4607182418800017408ULL );
+    BOOST_TEST_EQ( hv(std::complex<double>(-1.0, 0.0)), 13830554455654793216ULL );
+    BOOST_TEST_EQ( hv(std::complex<double>(0.0, +1.0)), 3750372589692780544ULL );
+    BOOST_TEST_EQ( hv(std::complex<double>(0.0, -1.0)), 10667901617333862400ULL );
+
+#endif
+
+    // pair
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::make_pair(0, 0)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::make_pair(1, 2)), 2507434894U );
+    BOOST_TEST_EQ( hv(std::make_pair(-1, -2)), 1874100199 );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::make_pair(0, 0)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::make_pair(1, 2)), 3370697991563800380ULL );
+    BOOST_TEST_EQ( hv(std::make_pair(-1, -2)), 4139767141999124554ULL );
+
+#endif
+
+    // vector<char>
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::vector<char>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::vector<char>(1)), 3864292196U );
+    BOOST_TEST_EQ( hv(std::vector<char>(2)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::vector<char>(3)), 325752138U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::vector<char>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::vector<char>(1)), 3864292196ULL );
+    BOOST_TEST_EQ( hv(std::vector<char>(2)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::vector<char>(3)), 17867750819888810972ULL );
+
+#endif
+
+    // vector<int>
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::vector<int>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::vector<int>(1)), 3864292196U );
+    BOOST_TEST_EQ( hv(std::vector<int>(2)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::vector<int>(3)), 325752138U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::vector<int>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::vector<int>(1)), 3864292196ULL );
+    BOOST_TEST_EQ( hv(std::vector<int>(2)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::vector<int>(3)), 17867750819888810972ULL );
+
+#endif
+
+    // vector<vector<int>>
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(0)), 0 );
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(1)), 3864292196U );
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(2)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(3)), 325752138U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(0)), 0 );
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(1)), 3864292196ULL );
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(2)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(3)), 17867750819888810972ULL );
+
+#endif
+
+    // list<char>
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::list<char>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::list<char>(1)), 3864292196U );
+    BOOST_TEST_EQ( hv(std::list<char>(2)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::list<char>(3)), 325752138U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::list<char>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::list<char>(1)), 3864292196ULL );
+    BOOST_TEST_EQ( hv(std::list<char>(2)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::list<char>(3)), 17867750819888810972ULL );
+
+#endif
+
+    // list<int>
+#if SIZE_MAX == 4294967295U
+
+    BOOST_TEST_EQ( hv(std::list<int>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::list<int>(1)), 3864292196U );
+    BOOST_TEST_EQ( hv(std::list<int>(2)), 2842917718U );
+    BOOST_TEST_EQ( hv(std::list<int>(3)), 325752138U );
+
+#else
+
+    BOOST_TEST_EQ( hv(std::list<int>(0)), 0 );
+    BOOST_TEST_EQ( hv(std::list<int>(1)), 3864292196ULL );
+    BOOST_TEST_EQ( hv(std::list<int>(2)), 14642545639667855512ULL );
+    BOOST_TEST_EQ( hv(std::list<int>(3)), 17867750819888810972ULL );
+
+#endif
+
+    return boost::report_errors();
+}
+
+#endif