Skip to content

Commit 7d35ad2

Browse files
vmichalHoney Goyal
vmichal
authored and
Honey Goyal
committed
[libcxx] Removal of narrowing conversions in flat_[multi]{set, map} tests for compatibility with MSVC (llvm#170909)
Impacts files in `test/std/containers/container.adaptors/flat.xxx`. No meaning is changed; only appropriate types are spelled out to prevent compiler warnings. - Replace `char`s and `short`s used in tests of `flat_[multi]{set, map}` with `long`s to prevent warnings about narrowing conversions when running tests. Allow increased test coverage for MSVC STL. - Make test code robust against evil overloads of operator comma .(2 files) - Add `[[maybe_unused]]` to some local `typedef`s that are sometimes unused due to usage of `LIBCPP_STATIC_ASSERT`. For discussion and suggested changes, see the LLVM Discord https://discord.com/channels/636084430946959380/636732894974312448/1445901676400742533
1 parent e643585 commit 7d35ad2

34 files changed

+277
-275
lines changed

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -29,8 +29,8 @@ constexpr void test() {
2929
// test_allocator is not propagated
3030
using C = test_less<int>;
3131
KeyContainer<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
32-
ValueContainer<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
33-
using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
32+
ValueContainer<long, test_allocator<long>> vs({2, 2, 1}, test_allocator<long>(7));
33+
using M = std::flat_map<int, long, C, decltype(ks), decltype(vs)>;
3434
auto mo = M(ks, vs, C(5));
3535
auto m = M({{3, 3}, {4, 4}, {5, 5}}, C(3), test_allocator<int>(2));
3636
m = mo;
@@ -39,23 +39,23 @@ constexpr void test() {
3939
assert(m.keys() == ks);
4040
assert(m.values() == vs);
4141
assert(m.keys().get_allocator() == test_allocator<int>(2));
42-
assert(m.values().get_allocator() == test_allocator<char>(2));
42+
assert(m.values().get_allocator() == test_allocator<long>(2));
4343

4444
// mo is unchanged
4545
assert(mo.key_comp() == C(5));
4646
assert(mo.keys() == ks);
4747
assert(mo.values() == vs);
4848
assert(mo.keys().get_allocator() == test_allocator<int>(6));
49-
assert(mo.values().get_allocator() == test_allocator<char>(7));
49+
assert(mo.values().get_allocator() == test_allocator<long>(7));
5050
}
5151
{
5252
// other_allocator is propagated
5353
using C = test_less<int>;
5454
using Ks = KeyContainer<int, other_allocator<int>>;
55-
using Vs = ValueContainer<char, other_allocator<char>>;
55+
using Vs = ValueContainer<long, other_allocator<long>>;
5656
auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
57-
auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
58-
using M = std::flat_map<int, char, C, Ks, Vs>;
57+
auto vs = Vs({2, 2, 1}, other_allocator<long>(7));
58+
using M = std::flat_map<int, long, C, Ks, Vs>;
5959
auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
6060
auto m = M({{3, 3}, {4, 4}, {5, 5}}, C(3), other_allocator<int>(2));
6161
m = mo;
@@ -64,14 +64,14 @@ constexpr void test() {
6464
assert(m.keys() == ks);
6565
assert(m.values() == vs);
6666
assert(m.keys().get_allocator() == other_allocator<int>(6));
67-
assert(m.values().get_allocator() == other_allocator<char>(7));
67+
assert(m.values().get_allocator() == other_allocator<long>(7));
6868

6969
// mo is unchanged
7070
assert(mo.key_comp() == C(5));
7171
assert(mo.keys() == ks);
7272
assert(mo.values() == vs);
7373
assert(mo.keys().get_allocator() == other_allocator<int>(6));
74-
assert(mo.values().get_allocator() == other_allocator<char>(7));
74+
assert(mo.values().get_allocator() == other_allocator<long>(7));
7575
}
7676
if (!TEST_IS_CONSTANT_EVALUATED) {
7777
// comparator is copied and invariant is preserved

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -33,19 +33,19 @@ using PC = std::pair<const int, long>;
3333

3434
void test_copy() {
3535
{
36-
std::flat_map<long, short> source = {{1, 2}, {2, 3}};
36+
std::flat_map<long, int> source = {{1, 2}, {2, 3}};
3737
std::flat_map s(source);
3838
ASSERT_SAME_TYPE(decltype(s), decltype(source));
3939
assert(s == source);
4040
}
4141
{
42-
std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
42+
std::flat_map<long, int, std::greater<long>> source = {{1, 2}, {2, 3}};
4343
std::flat_map s{source}; // braces instead of parens
4444
ASSERT_SAME_TYPE(decltype(s), decltype(source));
4545
assert(s == source);
4646
}
4747
{
48-
std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
48+
std::flat_map<long, int, std::greater<long>> source = {{1, 2}, {2, 3}};
4949
std::flat_map s(source, std::allocator<int>());
5050
ASSERT_SAME_TYPE(decltype(s), decltype(source));
5151
assert(s == source);
@@ -54,38 +54,38 @@ void test_copy() {
5454

5555
void test_containers() {
5656
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
57-
std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
57+
std::deque<long, test_allocator<long>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
5858
std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
59-
std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
60-
const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
59+
std::deque<long, test_allocator<long>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
60+
const std::pair<int, long> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
6161
{
6262
std::flat_map s(ks, vs);
6363

64-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
64+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::less<int>, decltype(ks), decltype(vs)>);
6565
assert(std::ranges::equal(s, expected));
6666
assert(s.keys().get_allocator().get_id() == 42);
6767
assert(s.values().get_allocator().get_id() == 43);
6868
}
6969
{
7070
std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs);
7171

72-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
72+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::less<int>, decltype(ks), decltype(vs)>);
7373
assert(std::ranges::equal(s, expected));
7474
assert(s.keys().get_allocator().get_id() == 42);
7575
assert(s.values().get_allocator().get_id() == 43);
7676
}
7777
{
7878
std::flat_map s(ks, vs, test_allocator<long>(0, 44));
7979

80-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
80+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::less<int>, decltype(ks), decltype(vs)>);
8181
assert(std::ranges::equal(s, expected));
8282
assert(s.keys().get_allocator().get_id() == 44);
8383
assert(s.values().get_allocator().get_id() == 44);
8484
}
8585
{
8686
std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, test_allocator<long>(0, 44));
8787

88-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
88+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::less<int>, decltype(ks), decltype(vs)>);
8989
assert(std::ranges::equal(s, expected));
9090
assert(s.keys().get_allocator().get_id() == 44);
9191
assert(s.values().get_allocator().get_id() == 44);
@@ -94,38 +94,38 @@ void test_containers() {
9494

9595
void test_containers_compare() {
9696
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
97-
std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
97+
std::deque<long, test_allocator<long>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
9898
std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
99-
std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
100-
const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
99+
std::deque<long, test_allocator<long>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
100+
const std::pair<int, long> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
101101
{
102102
std::flat_map s(ks, vs, std::greater<int>());
103103

104-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
104+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::greater<int>, decltype(ks), decltype(vs)>);
105105
assert(std::ranges::equal(s, expected));
106106
assert(s.keys().get_allocator().get_id() == 42);
107107
assert(s.values().get_allocator().get_id() == 43);
108108
}
109109
{
110110
std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>());
111111

112-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
112+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::greater<int>, decltype(ks), decltype(vs)>);
113113
assert(std::ranges::equal(s, expected));
114114
assert(s.keys().get_allocator().get_id() == 42);
115115
assert(s.values().get_allocator().get_id() == 43);
116116
}
117117
{
118118
std::flat_map s(ks, vs, std::greater<int>(), test_allocator<long>(0, 44));
119119

120-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
120+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::greater<int>, decltype(ks), decltype(vs)>);
121121
assert(std::ranges::equal(s, expected));
122122
assert(s.keys().get_allocator().get_id() == 44);
123123
assert(s.values().get_allocator().get_id() == 44);
124124
}
125125
{
126126
std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>(), test_allocator<long>(0, 44));
127127

128-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
128+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::greater<int>, decltype(ks), decltype(vs)>);
129129
assert(std::ranges::equal(s, expected));
130130
assert(s.keys().get_allocator().get_id() == 44);
131131
assert(s.values().get_allocator().get_id() == 44);
@@ -280,45 +280,45 @@ void test_initializer_list_compare() {
280280
}
281281

282282
void test_from_range() {
283-
std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
284-
const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
283+
std::list<std::pair<int, long>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
284+
const std::pair<int, long> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
285285
{
286286
std::flat_map s(std::from_range, r);
287-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>>);
287+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::less<int>>);
288288
assert(std::ranges::equal(s, expected));
289289
}
290290
{
291291
std::flat_map s(std::from_range, r, test_allocator<long>(0, 42));
292292
ASSERT_SAME_TYPE(
293293
decltype(s),
294294
std::flat_map<int,
295-
short,
295+
long,
296296
std::less<int>,
297297
std::vector<int, test_allocator<int>>,
298-
std::vector<short, test_allocator<short>>>);
298+
std::vector<long, test_allocator<long>>>);
299299
assert(std::ranges::equal(s, expected));
300300
assert(s.keys().get_allocator().get_id() == 42);
301301
assert(s.values().get_allocator().get_id() == 42);
302302
}
303303
}
304304

305305
void test_from_range_compare() {
306-
std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
307-
const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
306+
std::list<std::pair<int, long>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
307+
const std::pair<int, long> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
308308
{
309309
std::flat_map s(std::from_range, r, std::greater<int>());
310-
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>>);
310+
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, long, std::greater<int>>);
311311
assert(std::ranges::equal(s, expected));
312312
}
313313
{
314314
std::flat_map s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));
315315
ASSERT_SAME_TYPE(
316316
decltype(s),
317317
std::flat_map<int,
318-
short,
318+
long,
319319
std::greater<int>,
320320
std::vector<int, test_allocator<int>>,
321-
std::vector<short, test_allocator<short>>>);
321+
std::vector<long, test_allocator<long>>>);
322322
assert(std::ranges::equal(s, expected));
323323
assert(s.keys().get_allocator().get_id() == 42);
324324
assert(s.values().get_allocator().get_id() == 42);

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

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -32,19 +32,19 @@ using PC = std::pair<const int, long>;
3232

3333
void test_containers() {
3434
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
35-
std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
35+
std::deque<long, test_allocator<long>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
3636
std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
37-
std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
38-
const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
37+
std::deque<long, test_allocator<long>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
38+
const std::pair<int, long> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
3939
{
4040
std::pmr::monotonic_buffer_resource mr;
4141
std::pmr::monotonic_buffer_resource mr2;
4242
std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
43-
std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
43+
std::pmr::deque<long> pvs(vs.begin(), vs.end(), &mr);
4444
std::flat_map s(std::move(pks), std::move(pvs), &mr2);
4545

4646
ASSERT_SAME_TYPE(
47-
decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
47+
decltype(s), std::flat_map<int, long, std::less<int>, std::pmr::deque<int>, std::pmr::deque<long>>);
4848
assert(std::ranges::equal(s, expected));
4949
assert(s.keys().get_allocator().resource() == &mr2);
5050
assert(s.values().get_allocator().resource() == &mr2);
@@ -53,11 +53,11 @@ void test_containers() {
5353
std::pmr::monotonic_buffer_resource mr;
5454
std::pmr::monotonic_buffer_resource mr2;
5555
std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
56-
std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
56+
std::pmr::deque<long> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
5757
std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), &mr2);
5858

5959
ASSERT_SAME_TYPE(
60-
decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
60+
decltype(s), std::flat_map<int, long, std::less<int>, std::pmr::deque<int>, std::pmr::deque<long>>);
6161
assert(std::ranges::equal(s, expected));
6262
assert(s.keys().get_allocator().resource() == &mr2);
6363
assert(s.values().get_allocator().resource() == &mr2);
@@ -66,19 +66,19 @@ void test_containers() {
6666

6767
void test_containers_compare() {
6868
std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
69-
std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
69+
std::deque<long, test_allocator<long>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
7070
std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
71-
std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
72-
const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
71+
std::deque<long, test_allocator<long>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
72+
const std::pair<int, long> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
7373
{
7474
std::pmr::monotonic_buffer_resource mr;
7575
std::pmr::monotonic_buffer_resource mr2;
7676
std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
77-
std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
77+
std::pmr::deque<long> pvs(vs.begin(), vs.end(), &mr);
7878
std::flat_map s(std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
7979

8080
ASSERT_SAME_TYPE(
81-
decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
81+
decltype(s), std::flat_map<int, long, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<long>>);
8282
assert(std::ranges::equal(s, expected));
8383
assert(s.keys().get_allocator().resource() == &mr2);
8484
assert(s.values().get_allocator().resource() == &mr2);
@@ -87,11 +87,11 @@ void test_containers_compare() {
8787
std::pmr::monotonic_buffer_resource mr;
8888
std::pmr::monotonic_buffer_resource mr2;
8989
std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
90-
std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
90+
std::pmr::deque<long> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
9191
std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
9292

9393
ASSERT_SAME_TYPE(
94-
decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
94+
decltype(s), std::flat_map<int, long, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<long>>);
9595
assert(std::ranges::equal(s, expected));
9696
assert(s.keys().get_allocator().resource() == &mr2);
9797
assert(s.values().get_allocator().resource() == &mr2);

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -37,24 +37,24 @@ struct DefaultCtableComp {
3737

3838
template <template <class...> class KeyContainer, template <class...> class ValueContainer>
3939
constexpr void test() {
40-
std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
40+
std::pair<int, long> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
4141
{
4242
// flat_map(initializer_list<value_type>);
43-
using M = std::flat_map<int, short>;
44-
std::initializer_list<std::pair<int, short>> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
43+
using M = std::flat_map<int, long>;
44+
std::initializer_list<std::pair<int, long>> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
4545
M m(il);
4646
assert(std::equal(m.begin(), m.end(), expected, expected + 4));
4747
}
4848
{
4949
// flat_map(initializer_list<value_type>);
5050
// explicit(false)
51-
using M = std::flat_map<int, short>;
51+
using M = std::flat_map<int, long>;
5252
M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
5353
assert(std::equal(m.begin(), m.end(), expected, expected + 4));
5454
}
5555
{
5656
// flat_map(initializer_list<value_type>);
57-
using M = std::flat_map<int, short, std::greater<int>, KeyContainer<int, min_allocator<int>>>;
57+
using M = std::flat_map<int, long, std::greater<int>, KeyContainer<int, min_allocator<int>>>;
5858
M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
5959
assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
6060
}
@@ -79,7 +79,7 @@ constexpr void test() {
7979
{
8080
// flat_map(initializer_list<value_type>, const key_compare&);
8181
using C = test_less<int>;
82-
using M = std::flat_map<int, short, C>;
82+
using M = std::flat_map<int, long, C>;
8383
auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10));
8484
assert(std::equal(m.begin(), m.end(), expected, expected + 4));
8585
assert(m.key_comp() == C(10));
@@ -92,7 +92,7 @@ constexpr void test() {
9292
if (!TEST_IS_CONSTANT_EVALUATED) {
9393
// flat_map(initializer_list<value_type>, const key_compare&);
9494
// Sorting uses the comparator that was passed in
95-
using M = std::flat_map<int, short, std::function<bool(int, int)>, KeyContainer<int, min_allocator<int>>>;
95+
using M = std::flat_map<int, long, std::function<bool(int, int)>, KeyContainer<int, min_allocator<int>>>;
9696
auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, std::greater<int>());
9797
assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
9898
assert(m.key_comp()(2, 1) == true);

0 commit comments

Comments
 (0)