From bdc2840738db247cc4aa927dc8a73e48a7672ca0 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 19:52:16 +0300
Subject: [PATCH 01/20] Update test/Jamfile

---
 test/Jamfile.v2 | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index a9dddfb..3acc39a 100644
--- a/test/Jamfile.v2
+++ b/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

From 998d8da8c8d0d240e2da8059a85aee0b988177be Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 00:17:01 +0300
Subject: [PATCH 02/20] Disable warning in test/check_float_funcs.cpp

---
 test/check_float_funcs.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/check_float_funcs.cpp b/test/check_float_funcs.cpp
index 01d5168..74ca7cd 100644
--- a/test/check_float_funcs.cpp
+++ b/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>

From 3c3948ccdbdab07a6219ba409e518524f9795f69 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 00:31:08 +0300
Subject: [PATCH 03/20] Take care of size_t -> int warnings under g++ 4.8

---
 include/boost/container_hash/hash.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/container_hash/hash.hpp b/include/boost/container_hash/hash.hpp
index 06fa8a3..5ce09d4 100644
--- a/include/boost/container_hash/hash.hpp
+++ b/include/boost/container_hash/hash.hpp
@@ -308,7 +308,7 @@ namespace boost
              return seed;
         }
 
-        template<int Bits> struct hash_combine_impl
+        template<std::size_t Bits> struct hash_combine_impl
         {
             template <typename SizeT>
             inline static SizeT fn(SizeT seed, SizeT value)

From 5959103346ba716db58754b00c9626108ca9085b Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 20:13:56 +0300
Subject: [PATCH 04/20] Extend __GNUC__ warning suppression to __clang__

---
 test/hash_complex_test.cpp | 2 +-
 test/hash_float_test.hpp   | 2 +-
 test/hash_number_test.cpp  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/hash_complex_test.cpp b/test/hash_complex_test.cpp
index 5ecacbf..5afd7ac 100644
--- a/test/hash_complex_test.cpp
+++ b/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
 
diff --git a/test/hash_float_test.hpp b/test/hash_float_test.hpp
index fd31687..6b28a2e 100644
--- a/test/hash_float_test.hpp
+++ b/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
 
diff --git a/test/hash_number_test.cpp b/test/hash_number_test.cpp
index 72ab626..668a86c 100644
--- a/test/hash_number_test.cpp
+++ b/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
 

From f0e75dd010808b3014984982e3a245debda186a2 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 19:08:15 +0300
Subject: [PATCH 05/20] Reenable clang-win in appveyor.yml

---
 .appveyor.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.appveyor.yml b/.appveyor.yml
index 8511118..070fd4d 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -29,10 +29,10 @@ environment:
       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 2019
+      TOOLSET: clang-win
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\cygwin\bin;
       TOOLSET: gcc

From ebac66dc1e13703cf3e5d5893eb4039e9655b912 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 16:45:40 +0300
Subject: [PATCH 06/20] Print hash_info output in ci.yml

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ae0d91f..ff3cc30 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -137,6 +137,7 @@ jobs:
       - name: Run tests
         run: |
           cd ../boost-root
+          ./b2 -j3 --verbose-test libs/$LIBRARY/test//hash_info toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
           ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
 
   windows:
@@ -188,4 +189,5 @@ jobs:
         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

From 1c27af1e2e2a503e0a9631f14178f863b994a031 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Oct 2021 23:54:39 +0300
Subject: [PATCH 07/20] Add hash_reference_values.cpp

---
 test/Jamfile.v2                |   2 +
 test/hash_reference_values.cpp | 331 +++++++++++++++++++++++++++++++++
 2 files changed, 333 insertions(+)
 create mode 100644 test/hash_reference_values.cpp

diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 3acc39a..c46e8ff 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -84,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 ;
diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
new file mode 100644
index 0000000..1dba6a2
--- /dev/null
+++ b/test/hash_reference_values.cpp
@@ -0,0 +1,331 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+#include <vector>
+#include <list>
+#include <utility>
+#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 );
+    BOOST_TEST_EQ( hv((uint128)-1), 13835058055282163777ULL );
+
+#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 );
+    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 2139095040U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 4286578688U );
+
+    // 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 );
+    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(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 );
+    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 9218868437227405312ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 18442240474082181120ULL );
+
+#endif
+
+    // long double
+    BOOST_TEST_EQ( hv(0.0L), 0 );
+    BOOST_TEST_EQ( hv(-0.0L), 0 );
+
+#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
+
+    // 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 );
+
+    // 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();
+}

From f0bed679093d7085607938014ad78c4e5e083307 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 00:01:15 +0300
Subject: [PATCH 08/20] Update long double values for g++ 64 bit

---
 test/hash_reference_values.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 1dba6a2..f1241b5 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -163,6 +163,8 @@ int main()
     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 );
@@ -181,6 +183,30 @@ int main()
     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), 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), 11529215046068486143ULL );
+    BOOST_TEST_EQ( hv(-1.0L), 11529215046068518911ULL );
+    BOOST_TEST_EQ( hv(3.14L), 12059468778148142067ULL );
+    BOOST_TEST_EQ( hv(-3.14L), 12059468778147191795ULL );
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18446744073709551614ULL );
+
+#endif
+
 #endif
 
     // C array

From cfbc94b128cabb56d242ff5ecbe0802d7a2a3136 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 00:15:16 +0300
Subject: [PATCH 09/20] Update infinity reference values

---
 test/hash_reference_values.cpp | 49 ++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index f1241b5..d0f565f 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -2,6 +2,18 @@
 // 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(__clang__)
+# pragma clang diagnostic ignored "-Wlong-long"
+
+#elif defined(__GNUC__) && __cplusplus < 201100L
+
+BOOST_PRAGMA_MESSAGE("Skipping test under GCC in C++98 mode")
+int main() {}
+
+#else
+
 #include <boost/container_hash/hash.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <string>
@@ -124,9 +136,24 @@ int main()
     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 );
@@ -141,9 +168,19 @@ int main()
     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 );
@@ -154,9 +191,19 @@ int main()
     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
@@ -355,3 +402,5 @@ int main()
 
     return boost::report_errors();
 }
+
+#endif

From 4ff953b568f2472ce686ea295dba5cdb3eb410e6 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 00:37:46 +0300
Subject: [PATCH 10/20] Fix clang

---
 test/hash_reference_values.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index d0f565f..2e95015 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -4,16 +4,17 @@
 
 #include <boost/config/pragma_message.hpp>
 
-#if defined(__clang__)
-# pragma clang diagnostic ignored "-Wlong-long"
-
-#elif defined(__GNUC__) && __cplusplus < 201100L
+#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>

From 0a795c62a36f20fd50b70f99b19e8cf7c07a7f73 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 00:55:31 +0300
Subject: [PATCH 11/20] Update (uint128)-1 and long double infinity values

---
 test/hash_reference_values.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 2e95015..81f6f68 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -122,8 +122,17 @@ int main()
     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
+
+    BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
+
+#else
+
     BOOST_TEST_EQ( hv((uint128)-1), 13835058055282163777ULL );
 
+#endif
+
 #endif
 
     // float
@@ -241,18 +250,38 @@ int main()
     BOOST_TEST_EQ( hv(-1.0L), 3220176896U );
     BOOST_TEST_EQ( hv(3.14L), 2660156064U );
     BOOST_TEST_EQ( hv(-3.14L), 512672416U );
+
+#if !defined(__GLIBCXX__)
+
     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(std::numeric_limits<long double>::infinity()), 2146435072U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4293918720U );
+
+#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()), 18446744073709551615ULL );
     BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18446744073709551614ULL );
 
+#else
+
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 11529215046068502527ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 11529215046068535295ULL );
+
+#endif
+
 #endif
 
 #endif

From fca37b0d43aeec251bb55ba1323e78ad4a7920bc Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 01:11:24 +0300
Subject: [PATCH 12/20] Fix long double infinity

---
 test/hash_reference_values.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 81f6f68..77df8a1 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -272,13 +272,13 @@ int main()
 
 #if !defined(__GLIBCXX__)
 
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 18446744073709551615ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18446744073709551614ULL );
+    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()), 11529215046068502527ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 11529215046068535295ULL );
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18446744073709551614ULL );
 
 #endif
 

From 526e4d472d38985a32c7c7a5fcbf0c24938f31b3 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 02:16:50 +0300
Subject: [PATCH 13/20] Add reference values for std::complex

---
 test/hash_reference_values.cpp | 54 ++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 77df8a1..4197d1b 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -21,6 +21,7 @@ int main() {}
 #include <vector>
 #include <list>
 #include <utility>
+#include <complex>
 #include <limits>
 #include <climits>
 #include <cfloat>
@@ -330,6 +331,59 @@ int main()
     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
 

From cab5c6c8d7e4152d15459ade3e15e3f99f39f9c5 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 02:21:58 +0300
Subject: [PATCH 14/20] Update (uint128)-1 test

---
 test/hash_reference_values.cpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 4197d1b..0217048 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -124,15 +124,9 @@ int main()
     BOOST_TEST_EQ( hv((uint128)1), 1 );
     BOOST_TEST_EQ( hv((uint128)65535), 65535 );
 
-#if defined(BOOST_GCC) && BOOST_GCC < 100000
-
-    BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
-
-#else
-
-    BOOST_TEST_EQ( hv((uint128)-1), 13835058055282163777ULL );
-
-#endif
+    // (uint128)-1 does the former under gcc 9 and below, the latter under gcc 10+
+    BOOST_TEST_EQ( hv((uint128)(unsigned long long)-1), 18446744073709551615ULL );
+    BOOST_TEST_EQ( hv(~(uint128)0), 13835058055282163777ULL );
 
 #endif
 

From dbb410b7ef7e20a9040c7b47c0e5eefe079ae1fc Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 02:31:06 +0300
Subject: [PATCH 15/20] Update long double reference values for 32 bit GCC

---
 test/hash_reference_values.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 0217048..c48a0a1 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -241,10 +241,10 @@ int main()
 
 #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(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__)
 
@@ -253,8 +253,8 @@ int main()
 
 #else
 
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 2146435072U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4293918720U );
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 4294967295U );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4294967294U );
 
 #endif
 

From 7abcf22762b4ad8fd3abdcd4c60633fc3422656c Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 02:38:25 +0300
Subject: [PATCH 16/20] Update long double infinity reference values for 32 bit
 GCC-like without fpclassify

---
 test/hash_reference_values.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index c48a0a1..19e664b 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -248,8 +248,8 @@ int main()
 
 #if !defined(__GLIBCXX__)
 
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 2146435072U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4293918720U );
+    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 0xA0007FFFu );
+    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 0xA000FFFFu );
 
 #else
 

From 9e938aca41e524d9b804134d2bfecedc12ff5801 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 03:00:17 +0300
Subject: [PATCH 17/20] Revert "Update (uint128)-1 test"

This reverts commit cab5c6c8d7e4152d15459ade3e15e3f99f39f9c5.
---
 test/hash_reference_values.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 19e664b..5a0289c 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -124,9 +124,15 @@ int main()
     BOOST_TEST_EQ( hv((uint128)1), 1 );
     BOOST_TEST_EQ( hv((uint128)65535), 65535 );
 
-    // (uint128)-1 does the former under gcc 9 and below, the latter under gcc 10+
-    BOOST_TEST_EQ( hv((uint128)(unsigned long long)-1), 18446744073709551615ULL );
-    BOOST_TEST_EQ( hv(~(uint128)0), 13835058055282163777ULL );
+#if defined(BOOST_GCC) && BOOST_GCC < 100000
+
+    BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
+
+#else
+
+    BOOST_TEST_EQ( hv((uint128)-1), 13835058055282163777ULL );
+
+#endif
 
 #endif
 

From 1a4888cdb4fcc467caa6ce3035d4a4bb6ae34fab Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 03:01:41 +0300
Subject: [PATCH 18/20] Add (uint128)-1 comment

---
 test/hash_reference_values.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 5a0289c..842bfd3 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -126,6 +126,7 @@ int main()
 
 #if defined(BOOST_GCC) && BOOST_GCC < 100000
 
+    // This looks like some sort of miscompilation
     BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
 
 #else

From 8315ec2ba706ca53cd6b18ce5924c29b08913dd9 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Oct 2021 03:20:23 +0300
Subject: [PATCH 19/20] Comment out (uint128)-1 test under GCC 9 and below

---
 test/hash_reference_values.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/hash_reference_values.cpp b/test/hash_reference_values.cpp
index 842bfd3..85c69d4 100644
--- a/test/hash_reference_values.cpp
+++ b/test/hash_reference_values.cpp
@@ -126,8 +126,12 @@ int main()
 
 #if defined(BOOST_GCC) && BOOST_GCC < 100000
 
-    // This looks like some sort of miscompilation
-    BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
+    // 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
 

From 4a685b2b1640390312863320710fce678808acdf Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Tue, 19 Oct 2021 00:30:50 +0300
Subject: [PATCH 20/20] Add address-model=32 tests to ci.yml

---
 .github/workflows/ci.yml | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ff3cc30..5bd9858 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,33 +20,43 @@ jobs:
           - toolset: gcc-4.8
             cxxstd: "03,11"
             os: ubuntu-18.04
-            install: g++-4.8
+            install: g++-4.8-multilib
+            address-model: 32,64
           - toolset: gcc-5
             cxxstd: "03,11,14,1z"
             os: ubuntu-18.04
-            install: g++-5
+            install: g++-5-multilib
+            address-model: 32,64
           - toolset: gcc-6
             cxxstd: "03,11,14,1z"
             os: ubuntu-18.04
-            install: g++-6
+            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
+            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
+            install: g++-10-multilib
+            address-model: 32,64
           - toolset: gcc-11
             cxxstd: "03,11,14,17,20"
             os: ubuntu-20.04
-            install: g++-11
+            install: g++-11-multilib
+            address-model: 32,64
           - toolset: clang
             compiler: clang++-3.9
             cxxstd: "03,11,14"
@@ -137,8 +147,9 @@ jobs:
       - name: Run tests
         run: |
           cd ../boost-root
-          ./b2 -j3 --verbose-test libs/$LIBRARY/test//hash_info toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
+          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: