forked from project-arcana/clean-core
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy patharray.cc
More file actions
138 lines (105 loc) · 3.87 KB
/
Copy patharray.cc
File metadata and controls
138 lines (105 loc) · 3.87 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <nexus/monte_carlo_test.hh>
#include <nexus/test.hh>
#include <array>
#include <clean-core/alloc_array.hh>
#include <clean-core/array.hh>
#include <clean-core/assert.hh>
#include <clean-core/capped_array.hh>
#include <clean-core/fwd_array.hh>
#include <clean-core/vector.hh>
#include <typed-geometry/tg.hh>
TEST("cc::array")
{
cc::array<int> a;
CHECK(a.empty());
a = {1, 2, 3};
CHECK(a.size() == 3);
CHECK(tg::sum(a) == 6);
cc::array<int> b = a;
CHECK(a == b);
b[1] = 7;
CHECK(a != b);
b = std::move(a);
CHECK(a.empty());
CHECK(tg::sum(b) == 6);
}
TEST("cc::alloc_array")
{
cc::alloc_array<int> a;
CHECK(a.empty());
a = {1, 2, 3};
CHECK(a.size() == 3);
CHECK(tg::sum(a) == 6);
cc::alloc_array<int> b(cc::span<int>{a});
CHECK(a == b);
b[1] = 7;
CHECK(a != b);
b = std::move(a);
CHECK(a.empty());
CHECK(tg::sum(b) == 6);
}
TEST("cc::array fixed")
{
cc::array<int, 3> a;
a = cc::make_array(1, 2, 3);
CHECK(tg::sum(a) == 6);
// Test if initializer lists create fixed cc::arrays
{
cc::array list = {1, 2, 3};
cc::array list_single = {1};
cc::array list_single_size_t = {size_t(42)};
static_assert(std::is_same_v<decltype(list), cc::array<int, 3>>);
static_assert(std::is_same_v<decltype(list_single), cc::array<int, 1>>);
static_assert(std::is_same_v<decltype(list_single_size_t), cc::array<size_t, 1>>);
}
}
MONTE_CARLO_TEST("cc::array + fwd_array mct")
{
auto const make_int = [](tg::rng& rng) { return uniform(rng, -10, 10); };
addOp("gen int", make_int);
auto const addType = [&](auto obj) {
using array_t = decltype(obj);
addOp("default ctor", [] { return array_t(); });
if constexpr (std::is_copy_constructible_v<array_t>)
{
addOp("move ctor", [](array_t const& s) { return cc::move(array_t(s)); }).make_optional();
addOp("move assignment", [](array_t& a, array_t const& b) { a = array_t(b); }).make_optional();
addOp("copy ctor", [](array_t const& s) { return array_t(s); }).make_optional();
addOp("copy assignment", [](array_t& a, array_t const& b) { a = b; }).make_optional();
}
addOp("defaulted", [](tg::rng& rng) { return array_t::defaulted(uniform(rng, 0, 15)); });
addOp("filled", [](tg::rng& rng, int v) { return array_t::filled(uniform(rng, 0, 15), v); });
addOp("randomize", [&](tg::rng& rng, array_t& s) {
for (auto& v : s)
v = make_int(rng);
});
addOp("random replace", [&](tg::rng& rng, array_t& s) { random_choice(rng, s) = make_int(rng); }).when([](tg::rng&, array_t const& s) {
return s.size() > 0;
});
addOp("op[]", [](tg::rng& rng, array_t const& s) { return random_choice(rng, s); }).when([](tg::rng&, array_t const& s) {
return s.size() > 0;
});
addOp("data[]", [](tg::rng& rng, array_t const& s) {
return s.data()[uniform(rng, 0, int(s.size()) - 1)];
}).when([](tg::rng&, array_t const& s) { return s.size() > 0; });
addOp("fill", [](array_t& s, int v) {
for (auto& c : s)
c = v;
});
addOp("size", [](array_t const& a) { return a.size(); });
addOp("empty", [](array_t const& a) { return a.empty(); });
};
addType(cc::array<int>());
addType(cc::vector<int>());
addType(cc::fwd_array<int>());
testEquivalence([](cc::array<int> const& a, cc::vector<int> const& b) {
REQUIRE(a.size() == b.size());
for (auto i = 0; i < int(a.size()); ++i)
REQUIRE(a[i] == b[i]);
});
testEquivalence([](cc::array<int> const& a, cc::fwd_array<int> const& b) {
REQUIRE(a.size() == b.size());
for (auto i = 0; i < int(a.size()); ++i)
REQUIRE(a[i] == b[i]);
});
}