From 359112f61458fd557d0a9ac4a6d7ec5d92048ed2 Mon Sep 17 00:00:00 2001 From: morzhovets Date: Wed, 16 Oct 2024 22:58:16 +0400 Subject: [PATCH] Update libcxx/unord.map --- test/sources/libcxx/UnorderedMapTests.h | 8 ++ .../unord.map/unord.map.cnstr/deduct.pass.cpp | 74 +++++++++++++++++++ .../unord.map.cnstr/from_range.pass.cpp | 55 ++++++++++++++ .../unord.map.modifiers/insert_range.pass.cpp | 39 ++++++++++ 4 files changed, 176 insertions(+) create mode 100644 test/sources/libcxx/unord.map/unord.map.cnstr/from_range.pass.cpp create mode 100644 test/sources/libcxx/unord.map/unord.map.modifiers/insert_range.pass.cpp diff --git a/test/sources/libcxx/UnorderedMapTests.h b/test/sources/libcxx/UnorderedMapTests.h index 5b6744c0..d21afcff 100644 --- a/test/sources/libcxx/UnorderedMapTests.h +++ b/test/sources/libcxx/UnorderedMapTests.h @@ -274,6 +274,10 @@ LIBCXX_TEST_BEGIN(cnstr_init) #include "unord.map/unord.map.cnstr/init.pass.cpp" LIBCXX_TEST_END +LIBCXX_TEST_BEGIN(cnstr_from_range) +#include "unord.map/unord.map.cnstr/from_range.pass.cpp" +LIBCXX_TEST_END + LIBCXX_TEST_BEGIN(cnstr_init_size) #include "unord.map/unord.map.cnstr/init_size.pass.cpp" LIBCXX_TEST_END @@ -442,6 +446,10 @@ LIBCXX_TEST_BEGIN(modifiers_insert_or_assign) #include "unord.map/unord.map.modifiers/insert_or_assign.pass.cpp" LIBCXX_TEST_END +LIBCXX_TEST_BEGIN(modifiers_insert_range) +#include "unord.map/unord.map.modifiers/insert_range.pass.cpp" +LIBCXX_TEST_END + LIBCXX_TEST_BEGIN(modifiers_insert_rvalue) #include "unord.map/unord.map.modifiers/insert_rvalue.pass.cpp" LIBCXX_TEST_END diff --git a/test/sources/libcxx/unord.map/unord.map.cnstr/deduct.pass.cpp b/test/sources/libcxx/unord.map/unord.map.cnstr/deduct.pass.cpp index 4eaa1bd5..1703d27d 100644 --- a/test/sources/libcxx/unord.map/unord.map.cnstr/deduct.pass.cpp +++ b/test/sources/libcxx/unord.map/unord.map.cnstr/deduct.pass.cpp @@ -58,6 +58,28 @@ // unordered_map(initializer_list>, typename see below::size_type, Hash, // Allocator) // -> unordered_map, Allocator>; +// +// template>, +// class Pred = equal_to>, +// class Allocator = allocator>> +// unordered_map(from_range_t, R&&, typename see below::size_type = see below, +// Hash = Hash(), Pred = Pred(), Allocator = Allocator()) +// -> unordered_map, range-mapped-type, Hash, Pred, Allocator>; // C++23 +// +// template +// unordered_map(from_range_t, R&&, typename see below::size_type, Allocator) +// -> unordered_map, range-mapped-type, hash>, +// equal_to>, Allocator>; // C++23 +// +// template +// unordered_map(from_range_t, R&&, Allocator) +// -> unordered_map, range-mapped-type, hash>, +// equal_to>, Allocator>; // C++23 +// +// template +// unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator) +// -> unordered_map, range-mapped-type, Hash, +// equal_to>, Allocator>; // C++23 using P = std::pair; using PC = std::pair; @@ -218,6 +240,58 @@ int main(int, char**) ASSERT_SAME_TYPE(decltype(m2), momo::stdish::unordered_map); } +#if TEST_STD_VER >= 23 + { + using Range = std::array; + using Pred = test_equal_to; + using DefaultPred = std::equal_to; + using Hash = test_hash; + using DefaultHash = momo::HashCoder; + using Alloc = test_allocator; + + { // (from_range, range) + momo::stdish::unordered_map c(std::from_range, Range()); + static_assert(std::is_same_v>); + } + + { // (from_range, range, n) + momo::stdish::unordered_map c(std::from_range, Range(), std::size_t()); + static_assert(std::is_same_v>); + } + + { // (from_range, range, n, hash) + momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Hash()); + static_assert(std::is_same_v>); + } + + { // (from_range, range, n, hash, pred) + momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Hash(), Pred()); + static_assert(std::is_same_v>); + } + + { // (from_range, range, n, hash, pred, alloc) + momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Hash(), Pred(), Alloc()); + static_assert(std::is_same_v>); + } + + { // (from_range, range, n, alloc) + momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Alloc()); + static_assert(std::is_same_v>); + } + + // TODO(LWG 2713): uncomment this test once the constructor is added. + { // (from_range, range, alloc) + //momo::stdish::unordered_map c(std::from_range, Range(), Alloc()); + //static_assert(std::is_same_v>); + } + + { // (from_range, range, n, hash, alloc) + momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Hash(), Alloc()); + static_assert(std::is_same_v>); + } + } +#endif + #if MOMO_VERSION_MAJOR > 3 UnorderedContainerDeductionGuidesSfinaeAway>(); #endif diff --git a/test/sources/libcxx/unord.map/unord.map.cnstr/from_range.pass.cpp b/test/sources/libcxx/unord.map/unord.map.cnstr/from_range.pass.cpp new file mode 100644 index 00000000..7b4df8e2 --- /dev/null +++ b/test/sources/libcxx/unord.map/unord.map.cnstr/from_range.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +// +// Modified for https://github.com/morzhovets/momo project. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// template R> +// unordered_map(from_range_t, R&& rg, size_type n = see below, +// const hasher& hf = hasher(), const key_equal& eql = key_equal(), +// const allocator_type& a = allocator_type()); // C++23 +// +// template R> +// unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a) +// : unordered_map(from_range, std::forward(rg), n, hasher(), key_equal(), a) { } // C++23 +// +// template R> +// unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a) +// : unordered_map(from_range, std::forward(rg), n, hf, key_equal(), a) { } // C++23 + +void test_duplicates() { + using T = std::pair; + + std::array input = { + T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'} + }; + std::array expected = { + T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{4, 'a'} + }; + auto c = std::unordered_map(std::from_range, input); + assert(std::ranges::is_permutation(expected, c)); +} + +int main(int, char**) { + using T = std::pair; + for_all_iterators_and_allocators([]() { + test_unordered_map, test_equal_to, Alloc>(); + }); + test_unordered_map_move_only(); + test_duplicates(); + + static_assert(test_map_constraints()); + + test_map_exception_safety_throwing_copy(); + test_map_exception_safety_throwing_allocator(); + + return 0; +} diff --git a/test/sources/libcxx/unord.map/unord.map.modifiers/insert_range.pass.cpp b/test/sources/libcxx/unord.map/unord.map.modifiers/insert_range.pass.cpp new file mode 100644 index 00000000..00d47109 --- /dev/null +++ b/test/sources/libcxx/unord.map/unord.map.modifiers/insert_range.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +// +// Modified for https://github.com/morzhovets/momo project. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 +// Some fields in the test case variables are deliberately not explicitly initialized, this silences a warning on GCC. +// ADDITIONAL_COMPILE_FLAGS(gcc-style-warnings): -Wno-missing-field-initializers + +// + +// template R> +// void insert_range(R&& rg); // C++23 + +int main(int, char**) { + // Note: we want to use a pair with non-const elements for input (an assignable type is a lot more convenient) but + // have to use the exact `value_type` of the map (that is, `pair`) for the allocator. + using Pair = std::pair; + using ConstPair = std::pair; + for_all_iterators_and_allocators([]() { + test_map_set_insert_range, test_equal_to, Alloc>, Pair, Iter, Sent>(); + }); + + static_assert(test_map_constraints_insert_range()); + + test_map_insert_range_move_only(); + + test_map_insert_range_exception_safety_throwing_copy(); + test_unord_map_insert_range_exception_safety_throwing_allocator(); + + return 0; +}