Skip to content

Commit b6484f0

Browse files
huixie90huixie90
committed
review comments
1 parent 8bfed5d commit b6484f0

25 files changed

+492
-255
lines changed

‎libcxx/test/libcxx/containers/container.adaptors/flat.set/iterator.compile.pass.cpp

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
//
2+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
3+
// See https://llvm.org/LICENSE.txt for license information.
4+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5+
//
6+
//===----------------------------------------------------------------------===//
7+
8+
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
9+
10+
// <flat_set>
11+
12+
// test that iterators from different types of flat_set are not compatible
13+
14+
#include <deque>
15+
#include <functional>
16+
#include <flat_set>
17+
#include <type_traits>
18+
19+
using Iter1 = std::flat_set<int>::iterator;
20+
using Iter2 = std::flat_set<double>::iterator;
21+
using Iter3 = std::flat_set<int, std::greater<>>::iterator;
22+
using Iter4 = std::flat_set<int, std::less<int>, std::deque<int>>::iterator;
23+
24+
static_assert(std::is_convertible_v<Iter1, Iter1>);
25+
static_assert(!std::is_convertible_v<Iter1, Iter2>);
26+
static_assert(!std::is_convertible_v<Iter1, Iter3>);
27+
static_assert(!std::is_convertible_v<Iter1, Iter4>);
28+
29+
static_assert(!std::is_convertible_v<Iter2, Iter1>);
30+
static_assert(std::is_convertible_v<Iter2, Iter2>);
31+
static_assert(!std::is_convertible_v<Iter2, Iter3>);
32+
static_assert(!std::is_convertible_v<Iter2, Iter4>);
33+
34+
static_assert(!std::is_convertible_v<Iter3, Iter1>);
35+
static_assert(!std::is_convertible_v<Iter3, Iter2>);
36+
static_assert(std::is_convertible_v<Iter3, Iter3>);
37+
static_assert(!std::is_convertible_v<Iter3, Iter4>);
38+
39+
static_assert(!std::is_convertible_v<Iter4, Iter1>);
40+
static_assert(!std::is_convertible_v<Iter4, Iter2>);
41+
static_assert(!std::is_convertible_v<Iter4, Iter3>);
42+
static_assert(std::is_convertible_v<Iter4, Iter4>);

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct_pmr.pass.cpp

Lines changed: 61 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -30,65 +30,75 @@
3030
using P = std::pair<int, long>;
3131
using PC = std::pair<const int, long>;
3232

33-
void test_containers() {
34-
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
35-
std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
36-
const int expected[] = {1, 2, 3, INT_MAX};
33+
int main(int, char**) {
3734
{
38-
std::pmr::monotonic_buffer_resource mr;
39-
std::pmr::monotonic_buffer_resource mr2;
40-
std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
41-
std::flat_set s(std::move(pks), &mr2);
35+
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
36+
std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
37+
const int expected[] = {1, 2, 3, INT_MAX};
38+
{
39+
// template<class KeyContainer, class Allocator>
40+
// flat_set(KeyContainer, Allocator)
41+
// -> flat_set<typename KeyContainer::value_type,
42+
// less<typename KeyContainer::value_type>, KeyContainer>;
43+
std::pmr::monotonic_buffer_resource mr;
44+
std::pmr::monotonic_buffer_resource mr2;
45+
std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
46+
std::flat_set s(std::move(pks), &mr2);
4247

43-
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::less<int>, std::pmr::deque<int>>);
44-
assert(std::ranges::equal(s, expected));
45-
auto keys = std::move(s).extract();
46-
assert(keys.get_allocator().resource() == &mr2);
47-
}
48-
{
49-
std::pmr::monotonic_buffer_resource mr;
50-
std::pmr::monotonic_buffer_resource mr2;
51-
std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
52-
std::flat_set s(std::sorted_unique, std::move(pks), &mr2);
48+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::less<int>, std::pmr::deque<int>>);
49+
assert(std::ranges::equal(s, expected));
50+
auto keys = std::move(s).extract();
51+
assert(keys.get_allocator().resource() == &mr2);
52+
}
53+
{
54+
// template<class KeyContainer, class Allocator>
55+
// flat_set(sorted_unique_t, KeyContainer, Allocator)
56+
// -> flat_set<typename KeyContainer::value_type,
57+
// less<typename KeyContainer::value_type>, KeyContainer>;
58+
std::pmr::monotonic_buffer_resource mr;
59+
std::pmr::monotonic_buffer_resource mr2;
60+
std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
61+
std::flat_set s(std::sorted_unique, std::move(pks), &mr2);
5362

54-
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::less<int>, std::pmr::deque<int>>);
55-
assert(std::ranges::equal(s, expected));
56-
auto keys = std::move(s).extract();
57-
assert(keys.get_allocator().resource() == &mr2);
63+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::less<int>, std::pmr::deque<int>>);
64+
assert(std::ranges::equal(s, expected));
65+
auto keys = std::move(s).extract();
66+
assert(keys.get_allocator().resource() == &mr2);
67+
}
5868
}
59-
}
60-
61-
void test_containers_compare() {
62-
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
63-
std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
64-
const int expected[] = {INT_MAX, 3, 2, 1};
6569
{
66-
std::pmr::monotonic_buffer_resource mr;
67-
std::pmr::monotonic_buffer_resource mr2;
68-
std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
69-
std::flat_set s(std::move(pks), std::greater<int>(), &mr2);
70+
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
71+
std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
72+
const int expected[] = {INT_MAX, 3, 2, 1};
73+
{
74+
// template<class KeyContainer, class Compare, class Allocator>
75+
// flat_set(KeyContainer, Compare, Allocator)
76+
// -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
77+
std::pmr::monotonic_buffer_resource mr;
78+
std::pmr::monotonic_buffer_resource mr2;
79+
std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
80+
std::flat_set s(std::move(pks), std::greater<int>(), &mr2);
7081

71-
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::greater<int>, std::pmr::deque<int>>);
72-
assert(std::ranges::equal(s, expected));
73-
auto keys = std::move(s).extract();
74-
assert(keys.get_allocator().resource() == &mr2);
75-
}
76-
{
77-
std::pmr::monotonic_buffer_resource mr;
78-
std::pmr::monotonic_buffer_resource mr2;
79-
std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
80-
std::flat_set s(std::sorted_unique, std::move(pks), std::greater<int>(), &mr2);
82+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::greater<int>, std::pmr::deque<int>>);
83+
assert(std::ranges::equal(s, expected));
84+
auto keys = std::move(s).extract();
85+
assert(keys.get_allocator().resource() == &mr2);
86+
}
87+
{
88+
// template<class KeyContainer, class Compare, class Allocator>
89+
// flat_set(sorted_unique_t, KeyContainer, Compare, Allocator)
90+
// -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
91+
std::pmr::monotonic_buffer_resource mr;
92+
std::pmr::monotonic_buffer_resource mr2;
93+
std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
94+
std::flat_set s(std::sorted_unique, std::move(pks), std::greater<int>(), &mr2);
8195

82-
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::greater<int>, std::pmr::deque<int>>);
83-
assert(std::ranges::equal(s, expected));
84-
auto keys = std::move(s).extract();
85-
assert(keys.get_allocator().resource() == &mr2);
96+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::greater<int>, std::pmr::deque<int>>);
97+
assert(std::ranges::equal(s, expected));
98+
auto keys = std::move(s).extract();
99+
assert(keys.get_allocator().resource() == &mr2);
100+
}
86101
}
87-
}
88-
89-
int main(int, char**) {
90-
test_containers();
91-
test_containers_compare();
92102

93103
return 0;
94104
}

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if.pass.cpp

Lines changed: 14 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -48,15 +48,21 @@ void test0(
4848
assert(s == make<M>(expected));
4949
}
5050

51+
struct NotBool {
52+
bool b;
53+
explicit operator bool() const { return b; }
54+
};
55+
5156
template <class S>
5257
void test_one() {
5358
// Test all the plausible signatures for this predicate.
54-
auto is1 = [](typename S::const_reference v) { return v == 1; };
55-
auto is2 = [](typename S::value_type v) { return v == 2; };
56-
auto is3 = [](const typename S::value_type& v) { return v == 3; };
57-
auto is4 = [](auto v) { return v == 4; };
58-
auto True = [](const auto&) { return true; };
59-
auto False = [](auto&&) { return false; };
59+
auto is1 = [](typename S::const_reference v) { return v == 1; };
60+
auto is2 = [](typename S::value_type v) { return v == 2; };
61+
auto is3 = [](const typename S::value_type& v) { return v == 3; };
62+
auto is4 = [](auto v) { return v == 4; };
63+
auto True = [](const auto&) { return true; };
64+
auto False = [](auto&&) { return false; };
65+
auto nonBoolIs1 = [](const auto& v) { return NotBool{v == 1}; };
6066

6167
test0<S>({}, is1, {}, 0);
6268

@@ -74,6 +80,8 @@ void test_one() {
7480

7581
test0<S>({1, 2, 3}, True, {}, 3);
7682
test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
83+
84+
test0<S>({1, 2, 3}, nonBoolIs1, {2, 3}, 1);
7785
}
7886

7987
void test() {

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/clear.pass.cpp

Lines changed: 15 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -41,13 +41,21 @@ template <class KeyContainer>
4141
void test_one() {
4242
using Key = typename KeyContainer::value_type;
4343
using M = std::flat_set<Key, std::less<Key>, KeyContainer>;
44-
45-
M m = {1, 2, 3, 4, 5};
46-
assert(m.size() == 5);
47-
ASSERT_NOEXCEPT(m.clear());
48-
ASSERT_SAME_TYPE(decltype(m.clear()), void);
49-
m.clear();
50-
assert(m.size() == 0);
44+
{
45+
M m = {1, 2, 3, 4, 5};
46+
assert(m.size() == 5);
47+
ASSERT_NOEXCEPT(m.clear());
48+
ASSERT_SAME_TYPE(decltype(m.clear()), void);
49+
m.clear();
50+
assert(m.size() == 0);
51+
}
52+
{
53+
// was empty
54+
M m;
55+
assert(m.size() == 0);
56+
m.clear();
57+
assert(m.size() == 0);
58+
}
5159
}
5260

5361
void test() {

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter_iter.pass.cpp

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -75,6 +75,12 @@ void test_one() {
7575
assert(m.size() == 0);
7676
assert(i4 == m.begin());
7777
assert(i4 == m.end());
78+
79+
// was empty
80+
std::same_as<I> decltype(auto) i5 = m.erase(m.cbegin(), m.cend());
81+
assert(m.size() == 0);
82+
assert(i5 == m.begin());
83+
assert(i5 == m.end());
7884
}
7985

8086
void test() {

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key.pass.cpp

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -68,6 +68,10 @@ void test_one() {
6868
n = m.erase(5);
6969
assert(n == 1);
7070
assert(m.empty());
71+
// was empty
72+
n = m.erase(5);
73+
assert(n == 0);
74+
assert(m.empty());
7175
}
7276

7377
void test() {

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key_transparent.pass.cpp

Lines changed: 18 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -72,18 +72,27 @@ void test_one() {
7272
template <class KeyContainer>
7373
void test_transparent_comparator() {
7474
using M = std::flat_set<std::string, TransparentComparator, KeyContainer>;
75-
M m = {"alpha", "beta", "epsilon", "eta", "gamma"};
76-
ASSERT_SAME_TYPE(decltype(m.erase(Transparent<std::string>{"abc"})), typename M::size_type);
75+
{
76+
M m = {"alpha", "beta", "epsilon", "eta", "gamma"};
77+
ASSERT_SAME_TYPE(decltype(m.erase(Transparent<std::string>{"abc"})), typename M::size_type);
7778

78-
auto n = m.erase(Transparent<std::string>{"epsilon"});
79-
assert(n == 1);
79+
auto n = m.erase(Transparent<std::string>{"epsilon"});
80+
assert(n == 1);
8081

81-
M expected = {"alpha", "beta", "eta", "gamma"};
82-
assert(m == expected);
82+
M expected = {"alpha", "beta", "eta", "gamma"};
83+
assert(m == expected);
8384

84-
auto n2 = m.erase(Transparent<std::string>{"aaa"});
85-
assert(n2 == 0);
86-
assert(m == expected);
85+
auto n2 = m.erase(Transparent<std::string>{"aaa"});
86+
assert(n2 == 0);
87+
assert(m == expected);
88+
}
89+
{
90+
// was empty
91+
M m;
92+
auto n = m.erase(Transparent<std::string>{"epsilon"});
93+
assert(n == 0);
94+
assert(m.empty());
95+
}
8796
}
8897

8998
void test() {

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp

Lines changed: 16 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -35,14 +35,24 @@ static_assert(!CanExtract<std::flat_set<int> const&&>);
3535
template <class KeyContainer>
3636
void test_one() {
3737
using M = std::flat_set<int, std::less<int>, KeyContainer>;
38-
M m = M({1, 2, 3});
38+
{
39+
M m = M({1, 2, 3});
3940

40-
std::same_as<KeyContainer> auto keys = std::move(m).extract();
41+
std::same_as<KeyContainer> auto keys = std::move(m).extract();
4142

42-
auto expected_keys = {1, 2, 3};
43-
assert(std::ranges::equal(keys, expected_keys));
44-
check_invariant(m);
45-
LIBCPP_ASSERT(m.empty());
43+
auto expected_keys = {1, 2, 3};
44+
assert(std::ranges::equal(keys, expected_keys));
45+
check_invariant(m);
46+
LIBCPP_ASSERT(m.empty());
47+
}
48+
{
49+
// was empty
50+
M m;
51+
assert(m.empty());
52+
auto keys = std::move(m).extract();
53+
assert(keys.empty());
54+
LIBCPP_ASSERT(m.empty());
55+
}
4656
}
4757

4858
void test() {

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_initializer_list.pass.cpp

Lines changed: 37 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -28,24 +28,43 @@ void test_one() {
2828
using M = std::flat_set<Key, std::less<Key>, KeyContainer>;
2929
using V = typename M::value_type;
3030

31-
M m = {1, 1, 1, 3, 3, 3};
32-
m.insert({
33-
4,
34-
4,
35-
4,
36-
1,
37-
1,
38-
1,
39-
2,
40-
2,
41-
2,
42-
});
43-
assert(m.size() == 4);
44-
assert(std::distance(m.begin(), m.end()) == 4);
45-
assert(*m.begin() == V(1));
46-
assert(*std::next(m.begin()) == V(2));
47-
assert(*std::next(m.begin(), 2) == V(3));
48-
assert(*std::next(m.begin(), 3) == V(4));
31+
{
32+
M m = {1, 1, 1, 3, 3, 3};
33+
m.insert({
34+
4,
35+
4,
36+
4,
37+
1,
38+
1,
39+
1,
40+
2,
41+
2,
42+
2,
43+
});
44+
assert(m.size() == 4);
45+
assert(std::distance(m.begin(), m.end()) == 4);
46+
assert(*m.begin() == V(1));
47+
assert(*std::next(m.begin()) == V(2));
48+
assert(*std::next(m.begin(), 2) == V(3));
49+
assert(*std::next(m.begin(), 3) == V(4));
50+
}
51+
{
52+
// was empty
53+
M m;
54+
m.insert({
55+
4,
56+
4,
57+
4,
58+
1,
59+
1,
60+
1,
61+
2,
62+
2,
63+
2,
64+
});
65+
M expected = {1, 2, 4};
66+
assert(m == expected);
67+
}
4968
}
5069

5170
void test() {

0 commit comments

Comments
 (0)