Skip to content

Commit 000b09a

Browse files
huixie90huixie90
committed
parameterise tests
1 parent 5e306bf commit 000b09a

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

51 files changed

+1598
-2156
lines changed

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp

Lines changed: 14 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -14,15 +14,18 @@
1414
// const mapped_type& at(const key_type& k) const;
1515

1616
#include <cassert>
17+
#include <deque>
1718
#include <flat_map>
1819
#include <functional>
1920
#include <stdexcept>
2021
#include <vector>
2122

23+
#include "MinSequenceContainer.h"
2224
#include "min_allocator.h"
2325
#include "test_macros.h"
2426

25-
int main(int, char**) {
27+
template <class KeyContainer, class ValueContainer>
28+
void test() {
2629
using P = std::pair<int, double>;
2730
P ar[] = {
2831
P(1, 1.5),
@@ -35,7 +38,7 @@ int main(int, char**) {
3538
};
3639
const int one = 1;
3740
{
38-
std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
41+
std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
3942
ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
4043
assert(m.size() == 7);
4144
assert(m.at(one) == 1.5);
@@ -57,7 +60,8 @@ int main(int, char**) {
5760
assert(m.size() == 7);
5861
}
5962
{
60-
const std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
63+
const std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer> m(
64+
ar, ar + sizeof(ar) / sizeof(ar[0]));
6165
ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
6266
assert(m.size() == 7);
6367
assert(m.at(one) == 1.5);
@@ -76,58 +80,13 @@ int main(int, char**) {
7680
assert(m.at(8) == 8.5);
7781
assert(m.size() == 7);
7882
}
79-
{
80-
std::flat_map<int,
81-
double,
82-
std::less<int>,
83-
std::vector<int, min_allocator<int>>,
84-
std::vector<double, min_allocator<double>>>
85-
m(ar, ar + sizeof(ar) / sizeof(ar[0]));
86-
ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
87-
assert(m.size() == 7);
88-
assert(m.at(one) == 1.5);
89-
m.at(1) = -1.5;
90-
assert(m.at(1) == -1.5);
91-
assert(m.at(2) == 2.5);
92-
assert(m.at(3) == 3.5);
93-
assert(m.at(4) == 4.5);
94-
assert(m.at(5) == 5.5);
95-
#ifndef TEST_HAS_NO_EXCEPTIONS
96-
try {
97-
TEST_IGNORE_NODISCARD m.at(6);
98-
assert(false);
99-
} catch (std::out_of_range&) {
100-
}
101-
#endif
102-
assert(m.at(7) == 7.5);
103-
assert(m.at(8) == 8.5);
104-
assert(m.size() == 7);
105-
}
106-
{
107-
const std::flat_map<int,
108-
double,
109-
std::less<int>,
110-
std::vector<int, min_allocator<int>>,
111-
std::vector<double, min_allocator<double>>>
112-
m(ar, ar + sizeof(ar) / sizeof(ar[0]));
113-
ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
114-
assert(m.size() == 7);
115-
assert(m.at(1) == 1.5);
116-
assert(m.at(2) == 2.5);
117-
assert(m.at(3) == 3.5);
118-
assert(m.at(4) == 4.5);
119-
assert(m.at(5) == 5.5);
120-
#ifndef TEST_HAS_NO_EXCEPTIONS
121-
try {
122-
TEST_IGNORE_NODISCARD m.at(6);
123-
assert(false);
124-
} catch (std::out_of_range&) {
125-
}
126-
#endif
127-
assert(m.at(7) == 7.5);
128-
assert(m.at(8) == 8.5);
129-
assert(m.size() == 7);
130-
}
83+
}
84+
85+
int main(int, char**) {
86+
test<std::vector<int>, std::vector<double>>();
87+
test<std::deque<int>, std::vector<double>>();
88+
test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
89+
test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
13190

13291
return 0;
13392
}

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp

Lines changed: 15 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -14,12 +14,14 @@
1414
// template<class K> const mapped_type& at(const K& x) const;
1515

1616
#include <cassert>
17+
#include <deque>
1718
#include <flat_map>
1819
#include <functional>
1920
#include <stdexcept>
2021

2122
#include "../helpers.h"
2223
#include "min_allocator.h"
24+
#include "MinSequenceContainer.h"
2325
#include "test_macros.h"
2426

2527
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
@@ -32,7 +34,8 @@ static_assert(CanAt<const TransparentMap>);
3234
static_assert(!CanAt<NonTransparentMap>);
3335
static_assert(!CanAt<const NonTransparentMap>);
3436

35-
int main(int, char**) {
37+
template <class KeyContainer, class ValueContainer>
38+
void test() {
3639
using P = std::pair<int, double>;
3740
P ar[] = {
3841
P(1, 1.5),
@@ -45,54 +48,8 @@ int main(int, char**) {
4548
};
4649
const Transparent<int> one{1};
4750
{
48-
std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
49-
ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
50-
assert(m.size() == 7);
51-
assert(m.at(one) == 1.5);
52-
m.at(one) = -1.5;
53-
assert(m.at(Transparent<int>{1}) == -1.5);
54-
assert(m.at(Transparent<int>{2}) == 2.5);
55-
assert(m.at(Transparent<int>{3}) == 3.5);
56-
assert(m.at(Transparent<int>{4}) == 4.5);
57-
assert(m.at(Transparent<int>{5}) == 5.5);
58-
#ifndef TEST_HAS_NO_EXCEPTIONS
59-
try {
60-
TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
61-
assert(false);
62-
} catch (std::out_of_range&) {
63-
}
64-
#endif
65-
assert(m.at(Transparent<int>{7}) == 7.5);
66-
assert(m.at(Transparent<int>{8}) == 8.5);
67-
assert(m.size() == 7);
68-
}
69-
{
70-
const std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
71-
ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
72-
assert(m.size() == 7);
73-
assert(m.at(Transparent<int>{1}) == 1.5);
74-
assert(m.at(Transparent<int>{2}) == 2.5);
75-
assert(m.at(Transparent<int>{3}) == 3.5);
76-
assert(m.at(Transparent<int>{4}) == 4.5);
77-
assert(m.at(Transparent<int>{5}) == 5.5);
78-
#ifndef TEST_HAS_NO_EXCEPTIONS
79-
try {
80-
TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
81-
assert(false);
82-
} catch (std::out_of_range&) {
83-
}
84-
#endif
85-
assert(m.at(Transparent<int>{7}) == 7.5);
86-
assert(m.at(Transparent<int>{8}) == 8.5);
87-
assert(m.size() == 7);
88-
}
89-
{
90-
std::flat_map<int,
91-
double,
92-
TransparentComparator,
93-
std::vector<int, min_allocator<int>>,
94-
std::vector<double, min_allocator<double>>>
95-
m(ar, ar + sizeof(ar) / sizeof(ar[0]));
51+
std::flat_map<int, double, TransparentComparator, KeyContainer, ValueContainer> m(
52+
ar, ar + sizeof(ar) / sizeof(ar[0]));
9653
ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
9754
assert(m.size() == 7);
9855
assert(m.at(one) == 1.5);
@@ -114,12 +71,8 @@ int main(int, char**) {
11471
assert(m.size() == 7);
11572
}
11673
{
117-
const std::flat_map<int,
118-
double,
119-
TransparentComparator,
120-
std::vector<int, min_allocator<int>>,
121-
std::vector<double, min_allocator<double>>>
122-
m(ar, ar + sizeof(ar) / sizeof(ar[0]));
74+
const std::flat_map<int, double, TransparentComparator, KeyContainer, ValueContainer> m(
75+
ar, ar + sizeof(ar) / sizeof(ar[0]));
12376
ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
12477
assert(m.size() == 7);
12578
assert(m.at(Transparent<int>{1}) == 1.5);
@@ -138,6 +91,13 @@ int main(int, char**) {
13891
assert(m.at(Transparent<int>{8}) == 8.5);
13992
assert(m.size() == 7);
14093
}
94+
}
95+
96+
int main(int, char**) {
97+
test<std::vector<int>, std::vector<double>>();
98+
test<std::deque<int>, std::vector<double>>();
99+
test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
100+
test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
141101
{
142102
bool transparent_used = false;
143103
TransparentComparator c(transparent_used);

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp

Lines changed: 24 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,12 @@
1313
// mapped_type& operator[](const key_type& k);
1414

1515
#include <cassert>
16+
#include <deque>
1617
#include <flat_map>
1718
#include <functional>
19+
#include <vector>
1820

21+
#include "MinSequenceContainer.h"
1922
#include "../helpers.h"
2023
#include "min_allocator.h"
2124
#include "test_macros.h"
@@ -27,7 +30,8 @@ concept CanIndex = requires(M m, Input k) { m[k]; };
2730
static_assert(CanIndex<std::flat_map<int, double>, const int&>);
2831
static_assert(!CanIndex<std::flat_map<int, NoDefaultCtr>, const int&>);
2932

30-
int main(int, char**) {
33+
template <class KeyContainer, class ValueContainer>
34+
void test() {
3135
using P = std::pair<int, double>;
3236
P ar[] = {
3337
P(1, 1.5),
@@ -39,57 +43,26 @@ int main(int, char**) {
3943
P(8, 8.5),
4044
};
4145
const int one = 1;
42-
{
43-
std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
44-
ASSERT_SAME_TYPE(decltype(m[one]), double&);
45-
assert(m.size() == 7);
46-
assert(m[one] == 1.5);
47-
assert(m.size() == 7);
48-
m[1] = -1.5;
49-
assert(m[1] == -1.5);
50-
assert(m.size() == 7);
51-
assert(m[6] == 0);
52-
assert(m.size() == 8);
53-
m[6] = 6.5;
54-
assert(m[6] == 6.5);
55-
assert(m.size() == 8);
56-
}
57-
{
58-
// allocator
59-
using A1 = min_allocator<int>;
60-
using A2 = min_allocator<double>;
61-
using M = std::flat_map<int, double, std::less<int>, std::vector<int, A1>, std::vector<double, A2>>;
62-
M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
63-
ASSERT_SAME_TYPE(decltype(m[one]), double&);
64-
assert(m.size() == 7);
65-
assert(m[1] == 1.5);
66-
assert(m.size() == 7);
67-
const int i = 1;
68-
m[i] = -1.5;
69-
assert(m[1] == -1.5);
70-
assert(m.size() == 7);
71-
assert(m[6] == 0);
72-
assert(m.size() == 8);
73-
m[6] = 6.5;
74-
assert(m[6] == 6.5);
75-
assert(m.size() == 8);
76-
}
77-
{
78-
std::flat_map<int, double, std::less<>> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
79-
ASSERT_SAME_TYPE(decltype(m[one]), double&);
46+
std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
47+
ASSERT_SAME_TYPE(decltype(m[one]), double&);
48+
assert(m.size() == 7);
49+
assert(m[one] == 1.5);
50+
assert(m.size() == 7);
51+
m[1] = -1.5;
52+
assert(m[1] == -1.5);
53+
assert(m.size() == 7);
54+
assert(m[6] == 0);
55+
assert(m.size() == 8);
56+
m[6] = 6.5;
57+
assert(m[6] == 6.5);
58+
assert(m.size() == 8);
59+
}
8060

81-
assert(m.size() == 7);
82-
assert(m[1] == 1.5);
83-
assert(m.size() == 7);
84-
m[1] = -1.5;
85-
assert(m[1] == -1.5);
86-
assert(m.size() == 7);
87-
assert(m[6] == 0);
88-
assert(m.size() == 8);
89-
m[6] = 6.5;
90-
assert(m[6] == 6.5);
91-
assert(m.size() == 8);
92-
}
61+
int main(int, char**) {
62+
test<std::vector<int>, std::vector<double>>();
63+
test<std::deque<int>, std::vector<double>>();
64+
test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
65+
test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
9366

9467
{
9568
auto index_func = [](auto& m, auto key_arg, auto value_arg) {

‎libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp

Lines changed: 12 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,11 @@
1313
// mapped_type& operator[](key_type&& k);
1414

1515
#include <flat_map>
16+
#include <deque>
1617
#include <functional>
1718
#include <cassert>
1819

20+
#include "MinSequenceContainer.h"
1921
#include "../helpers.h"
2022
#include "test_macros.h"
2123
#include "MoveOnly.h"
@@ -28,29 +30,10 @@ concept CanIndex = requires(M m, Input k) { m[k]; };
2830
static_assert(CanIndex<std::flat_map<int, double>, int&&>);
2931
static_assert(!CanIndex<std::flat_map<int, NoDefaultCtr>, int&&>);
3032

31-
int main(int, char**) {
32-
{
33-
std::flat_map<MoveOnly, double> m;
34-
ASSERT_SAME_TYPE(decltype(m[MoveOnly{}]), double&);
35-
assert(m.size() == 0);
36-
assert(m[1] == 0.0);
37-
assert(m.size() == 1);
38-
m[1] = -1.5;
39-
assert(m[1] == -1.5);
40-
assert(m.size() == 1);
41-
assert(m[6] == 0);
42-
assert(m.size() == 2);
43-
m[6] = 6.5;
44-
assert(m[6] == 6.5);
45-
assert(m.size() == 2);
46-
}
33+
template <class KeyContainer, class ValueContainer>
34+
void test() {
4735
{
48-
std::flat_map< MoveOnly,
49-
double,
50-
std::less<>,
51-
std::vector<MoveOnly, min_allocator<MoveOnly>>,
52-
std::vector<double, min_allocator<double>>>
53-
m;
36+
std::flat_map<MoveOnly, double, std::less<MoveOnly>, KeyContainer, ValueContainer> m;
5437
ASSERT_SAME_TYPE(decltype(m[MoveOnly{}]), double&);
5538
assert(m.size() == 0);
5639
assert(m[1] == 0.0);
@@ -64,6 +47,13 @@ int main(int, char**) {
6447
assert(m[6] == 6.5);
6548
assert(m.size() == 2);
6649
}
50+
}
51+
52+
int main(int, char**) {
53+
test<std::vector<MoveOnly>, std::vector<double>>();
54+
test<std::deque<MoveOnly>, std::vector<double>>();
55+
test<MinSequenceContainer<MoveOnly>, MinSequenceContainer<double>>();
56+
test<std::vector<MoveOnly, min_allocator<MoveOnly>>, std::vector<double, min_allocator<double>>>();
6757

6858
{
6959
auto index_func = [](auto& m, auto key_arg, auto value_arg) {

0 commit comments

Comments
 (0)