[libcxx-commits] [libcxx] 6cefc30 - [libcxx][test][NFC] Add tests for C++14 constructors of unordered sets
Ruslan Arutyunyan via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Mar 3 04:16:14 PST 2022
Author: Ruslan Arutyunyan
Date: 2022-03-03T15:15:03+03:00
New Revision: 6cefc30a7fc83b91889aac631382f115e230b75d
URL: https://github.com/llvm/llvm-project/commit/6cefc30a7fc83b91889aac631382f115e230b75d
DIFF: https://github.com/llvm/llvm-project/commit/6cefc30a7fc83b91889aac631382f115e230b75d.diff
LOG: [libcxx][test][NFC] Add tests for C++14 constructors of unordered sets
Add tests for C++14 constructors in unordered_set and unordered_multiset:
unordered_[multi]set(size_type sz, const allocator_type& alloc);
unordered_[multi]set(size_type sz, const hasher& hash, const allocator_type& alloc);
template <class InputIt>
unordered_[multi]set(InputIt first, InputIt last, size_type sz, const allocator_type& alloc);
template <class InputIt>
unordered_[multi]set(InputIt first, InputIt last, size_type sz, const hasher& hash, const allocator_type& alloc);
unordered_[multi]set(initializer_list<value_type> init, size_type sz, const allocator_type& alloc);
unordered_[multi]set(initializer_list<value_type> init, size_type sz, const hasher& hash, const allocator_type& alloc);
Reviewed By: ldionne, Quuxplusone, rarutyun, #libc
Differential Revision: https://reviews.llvm.org/D119243
Added:
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_allocator.pass.cpp
Modified:
Removed:
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
################################################################################
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..4551de8a931fb
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_allocator.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// unordered_multiset(initializer_list<value_type> init, size_type n, const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_multiset<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ C c({
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ },
+ 7,
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+ assert(c.count(1) == 2);
+ assert(c.count(2) == 2);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..01e51b1951aae
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_allocator.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// unordered_multiset(initializer_list<value_type> init, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_multiset<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ C c({
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ },
+ 7,
+ test_hash<int>(5),
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+ assert(c.count(1) == 2);
+ assert(c.count(2) == 2);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..3d9509e76417d
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_allocator.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// template <class InputIterator>
+// unordered_multiset(InputIterator first, InputIterator last, size_type n,
+// const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_multiset<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ int a[] =
+ {
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ };
+ C c(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + sizeof(a)/sizeof(a[0])),
+ 7,
+ alloc
+ );
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+ assert(c.count(1) == 2);
+ assert(c.count(2) == 2);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..34341b26a79a6
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// template <class InputIterator>
+// unordered_multiset(InputIterator first, InputIterator last, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_multiset<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ int a[] =
+ {
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ };
+ C c(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + sizeof(a)/sizeof(a[0])),
+ 7,
+ test_hash<int>(5),
+ alloc
+ );
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 6);
+ assert(c.count(1) == 2);
+ assert(c.count(2) == 2);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
rename to libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_allocator.pass.cpp
new file mode 100644
index 0000000000000..2855487d32062
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_allocator.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// unordered_multiset(size_type n, const allocator_type& alloc);
+
+#include <unordered_set>
+#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_multiset<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**)
+{
+ test(test_allocator<NotConstructible>(10));
+ test(min_allocator<NotConstructible>());
+ test(explicit_allocator<NotConstructible>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..2c20093579b15
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_allocator.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// unordered_multiset(size_type n, const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_set>
+#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_multiset<NotConstructible,
+ test_hash<NotConstructible>,
+ test_equal_to<NotConstructible>,
+ Allocator> C;
+ C c(7, test_hash<NotConstructible>(5), alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.hash_function() == test_hash<NotConstructible>(5));
+ 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**)
+{
+ test(test_allocator<NotConstructible>(10));
+ test(min_allocator<NotConstructible>());
+ test(explicit_allocator<NotConstructible>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..340dbba9b49a9
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_allocator.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_set
+
+// unordered_set(initializer_list<value_type> init, size_type n, const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_set<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ C c({
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ },
+ 7,
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.count(1) == 1);
+ assert(c.count(2) == 1);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..ab5f7d9f9b504
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_allocator.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_set
+
+// unordered_set(initializer_list<value_type> init, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_set<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ C c({
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ },
+ 7,
+ test_hash<int>(5),
+ alloc);
+
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.count(1) == 1);
+ assert(c.count(2) == 1);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
rename to libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
rename to libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_allocator.pass.cpp
new file mode 100644
index 0000000000000..cfed6dfbb36c1
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_allocator.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_set
+
+// template <class InputIterator>
+// unordered_set(InputIterator first, InputIterator last, size_type n,
+// const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_set<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ int a[] =
+ {
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ };
+ C c(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + sizeof(a)/sizeof(a[0])),
+ 7,
+ alloc
+ );
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.count(1) == 1);
+ assert(c.count(2) == 1);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
rename to libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..2c44cba3b7520
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_set
+
+// template <class InputIterator>
+// unordered_set(InputIterator first, InputIterator last, size_type n,
+// const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_set>
+#include <cassert>
+#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_set<int,
+ test_hash<int>,
+ test_equal_to<int>,
+ Allocator> C;
+ int a[] =
+ {
+ 1,
+ 2,
+ 3,
+ 4,
+ 1,
+ 2
+ };
+ C c(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + sizeof(a)/sizeof(a[0])),
+ 7,
+ test_hash<int>(5),
+ alloc
+ );
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.size() == 4);
+ assert(c.count(1) == 1);
+ assert(c.count(2) == 1);
+ assert(c.count(3) == 1);
+ assert(c.count(4) == 1);
+ 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**)
+{
+ test(test_allocator<int>(10));
+ test(min_allocator<int>());
+ test(explicit_allocator<int>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
rename to libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
rename to libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_allocator.pass.cpp
new file mode 100644
index 0000000000000..d547ea2b4bda3
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_allocator.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_set
+
+// unordered_set(size_type n, const allocator_type& alloc);
+
+#include <unordered_set>
+#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_set<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**)
+{
+ test(test_allocator<NotConstructible>(10));
+ test(min_allocator<NotConstructible>());
+ test(explicit_allocator<NotConstructible>());
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_allocator.pass.cpp
new file mode 100644
index 0000000000000..972c0db3149d7
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_allocator.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+// class Alloc = allocator<Value>>
+// class unordered_set
+
+// unordered_set(size_type n, const hasher& hash, const allocator_type& alloc);
+
+#include <unordered_set>
+#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_set<NotConstructible,
+ test_hash<NotConstructible>,
+ test_equal_to<NotConstructible>,
+ Allocator> C;
+ C c(7, test_hash<NotConstructible>(5), alloc);
+ LIBCPP_ASSERT(c.bucket_count() == 7);
+ assert(c.hash_function() == test_hash<NotConstructible>(5));
+ 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**)
+{
+ test(test_allocator<NotConstructible>(10));
+ test(min_allocator<NotConstructible>());
+ test(explicit_allocator<NotConstructible>());
+
+ return 0;
+}
More information about the libcxx-commits
mailing list