[libcxx-commits] [libcxx] 41a62cc - [libcxx][test][NFC] Add tests for constructors of unordered [multi]map since C++14
Ruslan Arutyunyan via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Mar 3 08:26:50 PST 2022
Author: Ruslan Arutyunyan
Date: 2022-03-03T19:17:18+03:00
New Revision: 41a62cc0b4f5821df85e7b23ae53bc66d1d046c3
URL: https://github.com/llvm/llvm-project/commit/41a62cc0b4f5821df85e7b23ae53bc66d1d046c3
DIFF: https://github.com/llvm/llvm-project/commit/41a62cc0b4f5821df85e7b23ae53bc66d1d046c3.diff
LOG: [libcxx][test][NFC] Add tests for constructors of unordered [multi]map since C++14
Add tests for C++14 constructors in unordered_map and unordered_multimap
unordered_[multi]map(size_type sz, const allocator_type& alloc);
unordered_[multi]map(size_type sz, const hasher& hash, const allocator_type& alloc);
template <class InputIt>
unordered_[multi]map(InputIt first, InputIt last, size_type sz, const allocator_type& alloc);
template <class InputIt>
unordered_[multi]map(InputIt first, InputIt last, size_type sz, const hasher& hash, const allocator_type& alloc);
unordered_[multi]map(initializer_list<value_type> init, size_type sz, const allocator_type& alloc);
unordered_[multi]map(initializer_list<value_type> init, size_type sz, const hasher& hash, const allocator_type& alloc);
Reviewed By: ldionne, rarutyun, #libc
Differential Revision: https://reviews.llvm.org/D119236
Added:
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_allocator.pass.cpp
Modified:
Removed:
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
################################################################################
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..7e25ba298d21c
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_allocator.pass.cpp
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <string>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc) {
+ typedef std::unordered_map<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator
+ > C;
+ typedef std::pair<int, std::string> P;
+
+ C c({
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four"),
+ },
+ 7,
+ alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.at(1) == "one");
+ assert(c.at(2) == "two");
+ assert(c.at(3) == "three");
+ assert(c.at(4) == "four");
+ assert(c.hash_function() == test_hash<int>());
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+ assert(!c.empty());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> P;
+
+ test(test_allocator<P>(10));
+ test(min_allocator<P>());
+ test(explicit_allocator<P>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..70a631dbaef86
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_allocator.pass.cpp
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// unordered_map(initializer_list<value_type> il, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <string>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc) {
+ typedef std::unordered_map<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator
+ > C;
+ typedef std::pair<int, std::string> P;
+
+ C c({
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four"),
+ },
+ 7,
+ test_hash<int>(5),
+ alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.at(1) == "one");
+ assert(c.at(2) == "two");
+ assert(c.at(3) == "three");
+ assert(c.at(4) == "four");
+ assert(c.hash_function() == test_hash<int>(5));
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+ assert(!c.empty());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> P;
+
+ test(test_allocator<P>(10));
+ test(min_allocator<P>());
+ test(explicit_allocator<P>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
rename to libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
rename to libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..11ca33816e679
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_allocator.pass.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// template <class InputIt>
+// unordered_map(InputIt first, InputIt last, size_type n, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <string>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_map<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator
+ > C;
+ typedef std::pair<int, std::string> P;
+ P a[] =
+ {
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four"),
+ };
+
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a) / sizeof(a[0])),
+ 7,
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.at(1) == "one");
+ assert(c.at(2) == "two");
+ assert(c.at(3) == "three");
+ assert(c.at(4) == "four");
+ assert(c.hash_function() == test_hash<int>());
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+ assert(!c.empty());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> P;
+ test(test_allocator<P>(10));
+ test(min_allocator<P>());
+ test(explicit_allocator<P>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
rename to libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..3a18bdf0dda74
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_allocator.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// template <class InputIt>
+// unordered_map(InputIt first, InputIt last, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <string>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_map<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator
+ > C;
+ typedef std::pair<int, std::string> P;
+ P a[] =
+ {
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four"),
+ };
+
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a) / sizeof(a[0])),
+ 7,
+ test_hash<int>(5),
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.at(1) == "one");
+ assert(c.at(2) == "two");
+ assert(c.at(3) == "three");
+ assert(c.at(4) == "four");
+ assert(c.hash_function() == test_hash<int>(5));
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+ assert(!c.empty());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> P;
+ test(test_allocator<P>(10));
+ test(min_allocator<P>());
+ test(explicit_allocator<P>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
rename to libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
rename to libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_allocator.pass.cpp
new file mode 100644
index 0000000000000..fcc896014fa50
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_allocator.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// unordered_map(size_type n, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../NotConstructible.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc) {
+ typedef std::unordered_map<NotConstructible, NotConstructible,
+ test_hash<NotConstructible>,
+ test_equal_to<NotConstructible>,
+ Allocator
+ > C;
+
+ C c(7, alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.hash_function() == test_hash<NotConstructible>());
+ assert(c.key_eq() == test_equal_to<NotConstructible>());
+ assert(c.get_allocator() == alloc);
+ assert(c.size() == 0);
+ assert(c.empty());
+ assert(std::distance(c.begin(), c.end()) == 0);
+ assert(c.load_factor() == 0);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const NotConstructible, NotConstructible> V;
+
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..219d1466c55e1
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_allocator.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// unordered_map(size_type n, const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../NotConstructible.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc) {
+ typedef std::unordered_map<NotConstructible, NotConstructible,
+ test_hash<NotConstructible>,
+ test_equal_to<NotConstructible>,
+ Allocator
+ > C;
+
+ C c(7, test_hash<NotConstructible>(8), alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.hash_function() == test_hash<NotConstructible>(8));
+ assert(c.key_eq() == test_equal_to<NotConstructible>());
+ assert(c.get_allocator() == alloc);
+ assert(c.size() == 0);
+ assert(c.empty());
+ assert(std::distance(c.begin(), c.end()) == 0);
+ assert(c.load_factor() == 0);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const NotConstructible, NotConstructible> V;
+
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..523977190c217
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_allocator.pass.cpp
@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// unordered_multimap(initializer_list<value_type> il, size_type n,
+// const allocator_type& alloc);
+
+#include <unordered_map>
+#include <string>
+#include <set>
+#include <cassert>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../check_consecutive.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_multimap<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ typedef std::pair<int, std::string> P;
+ C c({
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four")
+ },
+ 7,
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+
+ typedef std::pair<typename C::const_iterator, typename C::const_iterator> Eq;
+ Eq eq = c.equal_range(1);
+ assert(std::distance(eq.first, eq.second) == 2);
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(1), c.end(), 1, s);
+
+ eq = c.equal_range(2);
+ assert(std::distance(eq.first, eq.second) == 2);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(2), c.end(), 2, s);
+
+ eq = c.equal_range(3);
+ assert(std::distance(eq.first, eq.second) == 1);
+ typename C::const_iterator i = eq.first;
+ assert(i->first == 3);
+ assert(i->second == "three");
+
+ eq = c.equal_range(4);
+ assert(std::distance(eq.first, eq.second) == 1);
+ i = eq.first;
+ assert(i->first == 4);
+ assert(i->second == "four");
+
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+ assert(c.hash_function() == test_hash<int>());
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> V;
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..6d0f4e5404afb
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_allocator.pass.cpp
@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// unordered_multimap(initializer_list<value_type> il, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <string>
+#include <set>
+#include <cassert>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../check_consecutive.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_multimap<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ typedef std::pair<int, std::string> P;
+ C c({
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four")
+ },
+ 7,
+ test_hash<int>(5),
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+
+ typedef std::pair<typename C::const_iterator, typename C::const_iterator> Eq;
+ Eq eq = c.equal_range(1);
+ assert(std::distance(eq.first, eq.second) == 2);
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(1), c.end(), 1, s);
+
+ eq = c.equal_range(2);
+ assert(std::distance(eq.first, eq.second) == 2);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(2), c.end(), 2, s);
+
+ eq = c.equal_range(3);
+ assert(std::distance(eq.first, eq.second) == 1);
+ typename C::const_iterator i = eq.first;
+ assert(i->first == 3);
+ assert(i->second == "three");
+
+ eq = c.equal_range(4);
+ assert(std::distance(eq.first, eq.second) == 1);
+ i = eq.first;
+ assert(i->first == 4);
+ assert(i->second == "four");
+
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+ assert(c.hash_function() == test_hash<int>(5));
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> V;
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..5c1f4b6e39f58
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_allocator.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// template <class InputIterator>
+// unordered_multimap(InputIterator first, InputIterator last, size_type n,
+// const allocator_type& alloc);
+
+#include <unordered_map>
+#include <string>
+#include <set>
+#include <cassert>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../../../check_consecutive.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_multimap<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ typedef std::pair<int, std::string> P;
+ P a[] =
+ {
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four")
+ };
+
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a) / sizeof(a[0])),
+ 7,
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+
+ typedef std::pair<typename C::const_iterator, typename C::const_iterator> Eq;
+ Eq eq = c.equal_range(1);
+ assert(std::distance(eq.first, eq.second) == 2);
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(1), c.end(), 1, s);
+
+ eq = c.equal_range(2);
+ assert(std::distance(eq.first, eq.second) == 2);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(2), c.end(), 2, s);
+
+ eq = c.equal_range(3);
+ assert(std::distance(eq.first, eq.second) == 1);
+ typename C::const_iterator i = eq.first;
+ assert(i->first == 3);
+ assert(i->second == "three");
+
+ eq = c.equal_range(4);
+ assert(std::distance(eq.first, eq.second) == 1);
+ i = eq.first;
+ assert(i->first == 4);
+ assert(i->second == "four");
+
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+ assert(c.hash_function() == test_hash<int>());
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> V;
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..82cb9fc443f2a
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_allocator.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// template <class InputIterator>
+// unordered_multimap(InputIterator first, InputIterator last, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <string>
+#include <set>
+#include <cassert>
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../../../check_consecutive.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_multimap<int, std::string,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ typedef std::pair<int, std::string> P;
+ P a[] =
+ {
+ P(1, "one"),
+ P(2, "two"),
+ P(3, "three"),
+ P(4, "four"),
+ P(1, "four"),
+ P(2, "four")
+ };
+
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a) / sizeof(a[0])),
+ 7,
+ test_hash<int>(5),
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+
+ typedef std::pair<typename C::const_iterator, typename C::const_iterator> Eq;
+ Eq eq = c.equal_range(1);
+ assert(std::distance(eq.first, eq.second) == 2);
+ std::multiset<std::string> s;
+ s.insert("one");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(1), c.end(), 1, s);
+
+ eq = c.equal_range(2);
+ assert(std::distance(eq.first, eq.second) == 2);
+ s.insert("two");
+ s.insert("four");
+ CheckConsecutiveKeys<typename C::const_iterator>(c.find(2), c.end(), 2, s);
+
+ eq = c.equal_range(3);
+ assert(std::distance(eq.first, eq.second) == 1);
+ typename C::const_iterator i = eq.first;
+ assert(i->first == 3);
+ assert(i->second == "three");
+
+ eq = c.equal_range(4);
+ assert(std::distance(eq.first, eq.second) == 1);
+ i = eq.first;
+ assert(i->first == 4);
+ assert(i->second == "four");
+
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(std::fabs(c.load_factor() - (float)c.size() / c.bucket_count()) < FLT_EPSILON);
+ assert(c.max_load_factor() == 1);
+ assert(c.hash_function() == test_hash<int>(5));
+ assert(c.key_eq() == test_equal_to<int>());
+ assert(c.get_allocator() == alloc);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const int, std::string> V;
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_allocator.pass.cpp
new file mode 100644
index 0000000000000..b90f6db7913b8
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_allocator.pass.cpp
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// unordered_multimap(size_type n, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../NotConstructible.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_multimap<NotConstructible, NotConstructible,
+ test_hash<NotConstructible>,
+ test_equal_to<NotConstructible>,
+ Allocator> C;
+ C c(7,
+ alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.hash_function() == test_hash<NotConstructible>());
+ assert(c.key_eq() == test_equal_to<NotConstructible>());
+ assert(c.get_allocator() == alloc);
+ assert(c.size() == 0);
+ assert(c.empty());
+ assert(std::distance(c.begin(), c.end()) == 0);
+ assert(c.load_factor() == 0);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const NotConstructible, NotConstructible> V;
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..ad98e99558d48
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_allocator.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+// class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// unordered_multimap(size_type n, const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_map>
+#include <cassert>
+#include <iterator>
+
+#include "test_macros.h"
+#include "../../../NotConstructible.h"
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class Allocator>
+void test(const Allocator& alloc)
+{
+ typedef std::unordered_multimap<NotConstructible, NotConstructible,
+ test_hash<NotConstructible>,
+ test_equal_to<NotConstructible>,
+ Allocator> C;
+ C c(7,
+ test_hash<NotConstructible>(8),
+ alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.hash_function() == test_hash<NotConstructible>(8));
+ assert(c.key_eq() == test_equal_to<NotConstructible>());
+ assert(c.get_allocator() == alloc);
+ assert(c.size() == 0);
+ assert(c.empty());
+ assert(std::distance(c.begin(), c.end()) == 0);
+ assert(c.load_factor() == 0);
+ assert(c.max_load_factor() == 1);
+}
+
+int main(int, char**)
+{
+ typedef std::pair<const NotConstructible, NotConstructible> V;
+ test(test_allocator<V>(10));
+ test(min_allocator<V>());
+ test(explicit_allocator<V>());
+
+ return 0;
+}
More information about the libcxx-commits
mailing list