diff --git a/include/boost/unordered/concurrent_flat_map.hpp b/include/boost/unordered/concurrent_flat_map.hpp
index a91a77e8..f957b0a5 100644
--- a/include/boost/unordered/concurrent_flat_map.hpp
+++ b/include/boost/unordered/concurrent_flat_map.hpp
@@ -419,16 +419,18 @@ namespace boost {
       }
 
       template <class InputIterator>
-      void insert(InputIterator begin, InputIterator end)
+      size_type insert(InputIterator begin, InputIterator end)
       {
-        for (auto pos = begin; pos != end; ++pos) {
+        size_type count_elements = 0;
+        for (auto pos = begin; pos != end; ++pos, ++count_elements) {
           table_.emplace(*pos);
         }
+        return count_elements;
       }
 
-      void insert(std::initializer_list<value_type> ilist)
+      size_type insert(std::initializer_list<value_type> ilist)
       {
-        this->insert(ilist.begin(), ilist.end());
+        return this->insert(ilist.begin(), ilist.end());
       }
 
       template <class M>
@@ -471,19 +473,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_visit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_visit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_visit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_visit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_visit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
-        this->insert_or_visit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_visit(ilist.begin(), ilist.end(), f);
       }
 
       template <class Ty, class F>
@@ -502,19 +506,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_cvisit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_cvisit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_cvisit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
       }
 
       template <class Ty, class F1, class F2>
@@ -535,23 +541,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_visit(
+      size_type insert_and_visit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_visit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_visit(
+      size_type insert_and_visit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F2)
-        this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class Ty, class F1, class F2>
@@ -572,23 +580,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_cvisit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class... Args> BOOST_FORCEINLINE bool emplace(Args&&... args)
diff --git a/include/boost/unordered/concurrent_flat_set.hpp b/include/boost/unordered/concurrent_flat_set.hpp
index 05f89e49..9aa2c8cc 100644
--- a/include/boost/unordered/concurrent_flat_set.hpp
+++ b/include/boost/unordered/concurrent_flat_set.hpp
@@ -425,16 +425,18 @@ namespace boost {
       }
 
       template <class InputIterator>
-      void insert(InputIterator begin, InputIterator end)
+      size_type insert(InputIterator begin, InputIterator end)
       {
-        for (auto pos = begin; pos != end; ++pos) {
+        size_type count_elements = 0;
+        for (auto pos = begin; pos != end; ++pos, ++count_elements) {
           table_.emplace(*pos);
         }
+        return count_elements;
       }
 
-      void insert(std::initializer_list<value_type> ilist)
+      size_type insert(std::initializer_list<value_type> ilist)
       {
-        this->insert(ilist.begin(), ilist.end());
+        return this->insert(ilist.begin(), ilist.end());
       }
 
       template <class F>
@@ -462,19 +464,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_visit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_visit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_visit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_visit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_visit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        this->insert_or_visit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_visit(ilist.begin(), ilist.end(), f);
       }
 
       template <class F>
@@ -502,19 +506,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_cvisit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_cvisit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_cvisit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
       }
 
       template <class F1, class F2>
@@ -546,22 +552,24 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_visit(
+      size_type insert_and_visit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_visit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_visit(std::initializer_list<value_type> ilist, F1 f1, F2 f2)
+      size_type insert_and_visit(std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class F1, class F2>
@@ -593,23 +601,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_cvisit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class... Args> BOOST_FORCEINLINE bool emplace(Args&&... args)
diff --git a/include/boost/unordered/concurrent_node_map.hpp b/include/boost/unordered/concurrent_node_map.hpp
index c9fb87cb..0b3eb2d9 100644
--- a/include/boost/unordered/concurrent_node_map.hpp
+++ b/include/boost/unordered/concurrent_node_map.hpp
@@ -426,16 +426,18 @@ namespace boost {
       }
 
       template <class InputIterator>
-      void insert(InputIterator begin, InputIterator end)
+      size_type insert(InputIterator begin, InputIterator end)
       {
-        for (auto pos = begin; pos != end; ++pos) {
+        size_type count_elements = 0;
+        for (auto pos = begin; pos != end; ++pos, ++count_elements) {
           table_.emplace(*pos);
         }
+        return count_elements;
       }
 
-      void insert(std::initializer_list<value_type> ilist)
+      size_type insert(std::initializer_list<value_type> ilist)
       {
-        this->insert(ilist.begin(), ilist.end());
+        return this->insert(ilist.begin(), ilist.end());
       }
 
       insert_return_type insert(node_type&& nh)
@@ -497,19 +499,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_visit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_visit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_visit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_visit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_visit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
-        this->insert_or_visit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_visit(ilist.begin(), ilist.end(), f);
       }
 
       template <class F>
@@ -549,19 +553,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_cvisit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_cvisit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_cvisit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
       }
 
       template <class F>
@@ -603,23 +609,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_visit(
+      size_type insert_and_visit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_visit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_visit(
+      size_type insert_and_visit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F2)
-        this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class F1, class F2>
@@ -662,23 +670,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_cvisit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class F1, class F2>
diff --git a/include/boost/unordered/concurrent_node_set.hpp b/include/boost/unordered/concurrent_node_set.hpp
index ef160606..cea51919 100644
--- a/include/boost/unordered/concurrent_node_set.hpp
+++ b/include/boost/unordered/concurrent_node_set.hpp
@@ -432,16 +432,18 @@ namespace boost {
       }
 
       template <class InputIterator>
-      void insert(InputIterator begin, InputIterator end)
+      size_type insert(InputIterator begin, InputIterator end)
       {
-        for (auto pos = begin; pos != end; ++pos) {
+        size_type count_elements = 0;
+        for (auto pos = begin; pos != end; ++pos, ++count_elements) {
           table_.emplace(*pos);
         }
+        return count_elements;
       }
 
-      void insert(std::initializer_list<value_type> ilist)
+      size_type insert(std::initializer_list<value_type> ilist)
       {
-        this->insert(ilist.begin(), ilist.end());
+        return this->insert(ilist.begin(), ilist.end());
       }
 
       insert_return_type insert(node_type&& nh)
@@ -488,19 +490,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_visit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_visit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_visit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_visit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_visit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        this->insert_or_visit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_visit(ilist.begin(), ilist.end(), f);
       }
 
       template <class F>
@@ -549,19 +553,21 @@ namespace boost {
       }
 
       template <class InputIterator, class F>
-      void insert_or_cvisit(InputIterator first, InputIterator last, F f)
+      size_type insert_or_cvisit(InputIterator first, InputIterator last, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_or_cvisit(*first, f);
         }
+        return count_elements;
       }
 
       template <class F>
-      void insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
+      size_type insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
-        this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
+        return this->insert_or_cvisit(ilist.begin(), ilist.end(), f);
       }
 
       template <class F>
@@ -614,22 +620,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_visit(
+      size_type insert_and_visit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_visit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_visit(std::initializer_list<value_type> ilist, F1 f1, F2 f2)
+      size_type insert_and_visit(
+        std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_visit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class F1, class F2>
@@ -683,23 +692,25 @@ namespace boost {
       }
 
       template <class InputIterator, class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         InputIterator first, InputIterator last, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        for (; first != last; ++first) {
+        size_type count_elements = 0;
+        for (; first != last; ++first, ++count_elements) {
           table_.emplace_and_cvisit(*first, f1, f2);
         }
+        return count_elements;
       }
 
       template <class F1, class F2>
-      void insert_and_cvisit(
+      size_type insert_and_cvisit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
       {
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
         BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
-        this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
+        return this->insert_and_cvisit(ilist.begin(), ilist.end(), f1, f2);
       }
 
       template <class F1, class F2>
diff --git a/test/cfoa/insert_tests.cpp b/test/cfoa/insert_tests.cpp
index 50bf5ebb..cc451a2d 100644
--- a/test/cfoa/insert_tests.cpp
+++ b/test/cfoa/insert_tests.cpp
@@ -149,7 +149,7 @@ namespace {
       }
 
       thread_runner(values2, [&x](boost::span<raii_convertible> s) {
-        x.insert(s.begin(), s.end());
+        BOOST_TEST_EQ(x.insert(s.begin(), s.end()), s.size());
       });
 
       BOOST_TEST_EQ(
@@ -768,11 +768,12 @@ namespace {
       std::atomic<std::uint64_t> num_invokes{0};
       thread_runner(
         values2, [&x, &num_invokes](boost::span<raii_convertible> s) {
-          x.insert_or_cvisit(s.begin(), s.end(),
-            [&num_invokes](typename X::value_type const& v) {
-              (void)v;
-              ++num_invokes;
-            });
+          BOOST_TEST_EQ(x.insert_or_cvisit(s.begin(), s.end(),
+                          [&num_invokes](typename X::value_type const& v) {
+                            (void)v;
+                            ++num_invokes;
+                          }),
+            s.size());
         });
 
       BOOST_TEST_EQ(num_invokes, values.size() - x.size());
@@ -813,17 +814,19 @@ namespace {
 
       std::atomic<std::uint64_t> num_inserts{0};
       std::atomic<std::uint64_t> num_invokes{0};
-      thread_runner(
-        values2, [&x, &num_inserts, &num_invokes](boost::span<raii_convertible> s) {
-          x.insert_and_cvisit(s.begin(), s.end(),
-            [&num_inserts](arg_type& v) {
-              (void)v;
-              ++num_inserts;
-            },            
-            [&num_invokes](typename X::value_type const& v) {
-              (void)v;
-              ++num_invokes;
-            });
+      thread_runner(values2,
+        [&x, &num_inserts, &num_invokes](boost::span<raii_convertible> s) {
+          BOOST_TEST_EQ(x.insert_and_cvisit(
+                          s.begin(), s.end(),
+                          [&num_inserts](arg_type& v) {
+                            (void)v;
+                            ++num_inserts;
+                          },
+                          [&num_invokes](typename X::value_type const& v) {
+                            (void)v;
+                            ++num_invokes;
+                          }),
+            s.size());
         });
 
       BOOST_TEST_EQ(num_inserts, x.size());
@@ -866,11 +869,12 @@ namespace {
       std::atomic<std::uint64_t> num_invokes{0};
       thread_runner(
         values2, [&x, &num_invokes](boost::span<raii_convertible> s) {
-          x.insert_or_visit(s.begin(), s.end(),
-            [&num_invokes](arg_type& v) {
-              (void)v;
-              ++num_invokes;
-            });
+          BOOST_TEST_EQ(x.insert_or_visit(s.begin(), s.end(),
+                          [&num_invokes](arg_type& v) {
+                            (void)v;
+                            ++num_invokes;
+                          }),
+            s.size());
         });
 
       BOOST_TEST_EQ(num_invokes, values.size() - x.size());
@@ -911,17 +915,19 @@ namespace {
 
       std::atomic<std::uint64_t> num_inserts{0};
       std::atomic<std::uint64_t> num_invokes{0};
-      thread_runner(
-        values2, [&x, &num_inserts, &num_invokes](boost::span<raii_convertible> s) {
-          x.insert_and_visit(s.begin(), s.end(),
-            [&num_inserts](arg_type& v) {
-              (void)v;
-              ++num_inserts;
-            },            
-            [&num_invokes](typename X::value_type const& v) {
-              (void)v;
-              ++num_invokes;
-            });
+      thread_runner(values2,
+        [&x, &num_inserts, &num_invokes](boost::span<raii_convertible> s) {
+          BOOST_TEST_EQ(x.insert_and_visit(
+                          s.begin(), s.end(),
+                          [&num_inserts](arg_type& v) {
+                            (void)v;
+                            ++num_inserts;
+                          },
+                          [&num_invokes](typename X::value_type const& v) {
+                            (void)v;
+                            ++num_invokes;
+                          }),
+            s.size());
         });
 
       BOOST_TEST_EQ(num_inserts, x.size());
@@ -996,8 +1002,9 @@ namespace {
       {
         X x;
 
-        thread_runner(
-          dummy, [&x, &init_list](boost::span<raii>) { x.insert(init_list); });
+        thread_runner(dummy, [&x, &init_list](boost::span<raii>) {
+          BOOST_TEST_EQ(x.insert(init_list), init_list.size());
+        });
 
         BOOST_TEST_EQ(x.size(), reference_cont.size());
 
@@ -1027,16 +1034,19 @@ namespace {
         X x;
 
         thread_runner(dummy, [&x, &init_list, &num_invokes](boost::span<raii>) {
-          x.insert_or_visit(init_list, [&num_invokes](arg_type& v) {
-            (void)v;
-            ++num_invokes;
-          });
+          BOOST_TEST_EQ(x.insert_or_visit(init_list,
+                          [&num_invokes](arg_type& v) {
+                            (void)v;
+                            ++num_invokes;
+                          }),
+            init_list.size());
 
-          x.insert_or_cvisit(
-            init_list, [&num_invokes](typename X::value_type const& v) {
-              (void)v;
-              ++num_invokes;
-            });
+          BOOST_TEST_EQ(x.insert_or_cvisit(init_list,
+                          [&num_invokes](typename X::value_type const& v) {
+                            (void)v;
+                            ++num_invokes;
+                          }),
+            init_list.size());
         });
 
         BOOST_TEST_EQ(num_invokes, (init_list.size() - x.size()) +
@@ -1070,29 +1080,32 @@ namespace {
 
         X x;
 
-        thread_runner(dummy, 
+        thread_runner(dummy,
           [&x, &init_list, &num_inserts, &num_invokes](boost::span<raii>) {
-          x.insert_and_visit(init_list, 
-            [&num_inserts](arg_type& v) {
-              (void)v;
-              ++num_inserts;
-            },            
-            [&num_invokes](arg_type& v) {
-              (void)v;
-              ++num_invokes;
-            });
+            BOOST_TEST_EQ(x.insert_and_visit(
+                            init_list,
+                            [&num_inserts](arg_type& v) {
+                              (void)v;
+                              ++num_inserts;
+                            },
+                            [&num_invokes](arg_type& v) {
+                              (void)v;
+                              ++num_invokes;
+                            }),
+              init_list.size());
 
-          x.insert_and_cvisit(
-            init_list, 
-            [&num_inserts](arg_type& v) {
-              (void)v;
-              ++num_inserts;
-            },            
-            [&num_invokes](typename X::value_type const& v) {
-              (void)v;
-              ++num_invokes;
-            });
-        });
+            BOOST_TEST_EQ(x.insert_and_cvisit(
+                            init_list,
+                            [&num_inserts](arg_type& v) {
+                              (void)v;
+                              ++num_inserts;
+                            },
+                            [&num_invokes](typename X::value_type const& v) {
+                              (void)v;
+                              ++num_invokes;
+                            }),
+              init_list.size());
+          });
 
         BOOST_TEST_EQ(num_inserts, x.size());
         BOOST_TEST_EQ(num_invokes, (init_list.size() - x.size()) +