Skip to content

Commit

Permalink
Update libcxx/unord.map
Browse files Browse the repository at this point in the history
  • Loading branch information
morzhovets committed Oct 16, 2024
1 parent 7d13e81 commit 359112f
Show file tree
Hide file tree
Showing 4 changed files with 176 additions and 0 deletions.
8 changes: 8 additions & 0 deletions test/sources/libcxx/UnorderedMapTests.h
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down
74 changes: 74 additions & 0 deletions test/sources/libcxx/unord.map/unord.map.cnstr/deduct.pass.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -58,6 +58,28 @@
// unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
// Allocator)
// -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
//
// template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
// class Pred = equal_to<range-key-type<R>>,
// class Allocator = allocator<range-to-alloc-type<R>>>
// unordered_map(from_range_t, R&&, typename see below::size_type = see below,
// Hash = Hash(), Pred = Pred(), Allocator = Allocator())
// -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
//
// template<ranges::input_range R, class Allocator>
// unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
// -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
// equal_to<range-key-type<R>>, Allocator>; // C++23
//
// template<ranges::input_range R, class Allocator>
// unordered_map(from_range_t, R&&, Allocator)
// -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
// equal_to<range-key-type<R>>, Allocator>; // C++23
//
// template<ranges::input_range R, class Hash, class Allocator>
// unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
// -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash,
// equal_to<range-key-type<R>>, Allocator>; // C++23

using P = std::pair<int, long>;
using PC = std::pair<const int, long>;
Expand Down Expand Up @@ -218,6 +240,58 @@ int main(int, char**)
ASSERT_SAME_TYPE(decltype(m2), momo::stdish::unordered_map<int, int>);
}

#if TEST_STD_VER >= 23
{
using Range = std::array<P, 0>;
using Pred = test_equal_to<int>;
using DefaultPred = std::equal_to<int>;
using Hash = test_hash<int>;
using DefaultHash = momo::HashCoder<int>;
using Alloc = test_allocator<PC>;

{ // (from_range, range)
momo::stdish::unordered_map c(std::from_range, Range());
static_assert(std::is_same_v<decltype(c), momo::stdish::unordered_map<int, long>>);
}

{ // (from_range, range, n)
momo::stdish::unordered_map c(std::from_range, Range(), std::size_t());
static_assert(std::is_same_v<decltype(c), momo::stdish::unordered_map<int, long>>);
}

{ // (from_range, range, n, hash)
momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Hash());
static_assert(std::is_same_v<decltype(c), momo::stdish::unordered_map<int, long, Hash>>);
}

{ // (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<decltype(c), momo::stdish::unordered_map<int, long, Hash, Pred>>);
}

{ // (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<decltype(c), momo::stdish::unordered_map<int, long, Hash, Pred, Alloc>>);
}

{ // (from_range, range, n, alloc)
momo::stdish::unordered_map c(std::from_range, Range(), std::size_t(), Alloc());
static_assert(std::is_same_v<decltype(c), momo::stdish::unordered_map<int, long, DefaultHash, DefaultPred, Alloc>>);
}

// 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<decltype(c), momo::stdish::unordered_map<int, long, DefaultHash, DefaultPred, Alloc>>);
}

{ // (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<decltype(c), momo::stdish::unordered_map<int, long, Hash, DefaultPred, Alloc>>);
}
}
#endif

#if MOMO_VERSION_MAJOR > 3
UnorderedContainerDeductionGuidesSfinaeAway<momo::stdish::unordered_map, momo::stdish::unordered_map<int, long>>();
#endif
Expand Down
55 changes: 55 additions & 0 deletions test/sources/libcxx/unord.map/unord.map.cnstr/from_range.pass.cpp
Original file line number Diff line number Diff line change
@@ -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<container-compatible-range<value_type> 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<container-compatible-range<value_type> R>
// unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
// : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
//
// template<container-compatible-range<value_type> R>
// unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
// : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } // C++23

void test_duplicates() {
using T = std::pair<const int, char>;

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<int, char>(std::from_range, input);
assert(std::ranges::is_permutation(expected, c));
}

int main(int, char**) {
using T = std::pair<const int, int>;
for_all_iterators_and_allocators<T>([]<class Iter, class Sent, class Alloc>() {
test_unordered_map<std::unordered_map, int, int, Iter, Sent, test_hash<int>, test_equal_to<int>, Alloc>();
});
test_unordered_map_move_only<std::unordered_map>();
test_duplicates();

static_assert(test_map_constraints<std::unordered_map, int, int, double, double>());

test_map_exception_safety_throwing_copy<std::unordered_map>();
test_map_exception_safety_throwing_allocator<std::unordered_map, int, int>();

return 0;
}
Original file line number Diff line number Diff line change
@@ -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

// <unordered_map>

// template<container-compatible-range<value_type> 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<const K, V>`) for the allocator.
using Pair = std::pair<int, char>;
using ConstPair = std::pair<const int, char>;
for_all_iterators_and_allocators<ConstPair, const Pair*>([]<class Iter, class Sent, class Alloc>() {
test_map_set_insert_range<std::unordered_map<int, char, test_hash<int>, test_equal_to<int>, Alloc>, Pair, Iter, Sent>();
});

static_assert(test_map_constraints_insert_range<std::unordered_map, int, int, char, double>());

test_map_insert_range_move_only<std::unordered_map>();

test_map_insert_range_exception_safety_throwing_copy<std::unordered_map>();
test_unord_map_insert_range_exception_safety_throwing_allocator<std::unordered_map, int, int>();

return 0;
}

0 comments on commit 359112f

Please sign in to comment.