Add find_tests

include/boost/unordered/unordered_flat_map.hpp

@@ -43,7 +43,9 @@ namespace boost {
       using mapped_type = T;
       using value_type = typename map_types::value_type;
       using size_type = std::size_t;
+      using hasher = Hash;
       using key_equal = KeyEqual;
+      using allocator_type = Allocator;
       using reference = value_type&;
       using const_reference = value_type const&;
       using iterator = typename table_type::iterator;
@@ -57,6 +59,24 @@ namespace boost {
       const_iterator end() const noexcept { return table_.end(); }
       const_iterator cend() const noexcept { return table_.cend(); }
 
+      unordered_flat_map() : unordered_flat_map(0) {}
+
+      explicit unordered_flat_map(size_type n, hasher const& h = hasher(),
+        key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : table_(n, h, pred, a)
+      {
+      }
+
+      template <class Iterator>
+      unordered_flat_map(Iterator first, Iterator last, size_type n = 0,
+        hasher const& h = hasher(), key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : unordered_flat_map(n, h, pred, a)
+      {
+        this->insert(first, last);
+      }
+
       /// Capacity
       ///
 

include/boost/unordered/unordered_flat_set.hpp

@@ -10,8 +10,8 @@
 #pragma once
 #endif
 
-#include <boost/unordered/unordered_flat_set_fwd.hpp>
 #include <boost/unordered/detail/foa.hpp>
+#include <boost/unordered/unordered_flat_set_fwd.hpp>
 
 #include <boost/core/allocator_access.hpp>
 
@@ -42,12 +42,32 @@ namespace boost {
       using key_type = Key;
       using value_type = typename set_types::value_type;
       using size_type = std::size_t;
+      using hasher = Hash;
       using key_equal = KeyEqual;
+      using allocator_type = Allocator;
       using reference = value_type&;
       using const_reference = value_type const&;
       using iterator = typename table_type::iterator;
       using const_iterator = typename table_type::const_iterator;
 
+      unordered_flat_set() : unordered_flat_set(0) {}
+
+      explicit unordered_flat_set(size_type n, hasher const& h = hasher(),
+        key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : table_(n, h, pred, a)
+      {
+      }
+
+      template <class Iterator>
+      unordered_flat_set(Iterator first, Iterator last, size_type n = 0,
+        hasher const& h = hasher(), key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : unordered_flat_set(n, h, pred, a)
+      {
+        this->insert(first, last);
+      }
+
       iterator begin() noexcept { return table_.begin(); }
       const_iterator begin() const noexcept { return table_.begin(); }
       const_iterator cbegin() const noexcept { return table_.cbegin(); }

test/Jamfile.v2

@@ -67,6 +67,7 @@ compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_MULTIM
 compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_SET : insert_node_type_fail_set ;
 compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_MULTISET : insert_node_type_fail_multiset ;
 run unordered/find_tests.cpp ;
+run unordered/find_tests.cpp : : : $(CPP14) <define>BOOST_UNORDERED_FOA_TESTS : foa_find_tests ;
 run unordered/at_tests.cpp ;
 run unordered/bucket_tests.cpp ;
 run unordered/load_factor_tests.cpp ;

test/unordered/find_tests.cpp

@@ -1,14 +1,20 @@
 
 // Copyright 2006-2009 Daniel James.
+// Copyright (C) 2022 Christian Mazakas
 // 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)
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+#include <boost/unordered_flat_map.hpp>
+#include <boost/unordered_flat_set.hpp>
+#else
 // clang-format off
 #include "../helpers/prefix.hpp"
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/postfix.hpp"
 // clang-format on
+#endif
 
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
@@ -133,6 +139,20 @@ namespace find_tests {
     }
   }
 
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_set;
+  boost::unordered_flat_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
+
+  UNORDERED_TEST(
+    find_tests1, ((test_set)(test_map))(
+                   (default_generator)(generate_collisions)(limited_range)))
+#else
   boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_set;
   boost::unordered_multiset<test::object, test::hash, test::equal_to,
@@ -142,16 +162,13 @@ namespace find_tests {
   boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_multimap;
 
-  using test::default_generator;
-  using test::generate_collisions;
-  using test::limited_range;
-
   UNORDERED_TEST(
     find_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(find_compatible_keys_test,
     ((test_set)(test_multiset)(test_map)(test_multimap))(
       (default_generator)(generate_collisions)(limited_range)))
+#endif
 }
 
 RUN_TESTS()