Branch data Line data Source code
1 : : // Copyright (c) 2015-present The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <prevector.h>
6 : : #include <serialize.h>
7 : : #include <streams.h>
8 : : #include <test/util/random.h>
9 : : #include <test/util/setup_common.h>
10 : :
11 : : #include <boost/test/unit_test.hpp>
12 : :
13 : : #include <ranges>
14 : : #include <vector>
15 : :
16 : : BOOST_FIXTURE_TEST_SUITE(prevector_tests, TestingSetup)
17 : :
18 : : template <unsigned int N, typename T>
19 : : class prevector_tester
20 : : {
21 : : typedef std::vector<T> realtype;
22 : : realtype real_vector;
23 : : realtype real_vector_alt;
24 : :
25 : : typedef prevector<N, T> pretype;
26 : : pretype pre_vector;
27 : : pretype pre_vector_alt;
28 : :
29 : : typedef typename pretype::size_type Size;
30 : : bool passed = true;
31 : : uint256 rand_seed;
32 : :
33 : :
34 : : template <typename A, typename B>
35 : 9337697 : void local_check_equal(A a, B b)
36 : : {
37 : 9337697 : local_check(a == b);
38 : : }
39 : 22631189 : void local_check(bool b)
40 : : {
41 : 8498396 : passed &= b;
42 : : }
43 : 268903 : void test()
44 : : {
45 : 268903 : const pretype& const_pre_vector = pre_vector;
46 [ + + ]: 447362 : local_check_equal(real_vector.size(), pre_vector.size());
47 : 268903 : local_check_equal(real_vector.empty(), pre_vector.empty());
48 [ + + ]: 2393502 : for (Size s = 0; s < real_vector.size(); s++) {
49 [ + + ]: 2124599 : local_check(real_vector[s] == pre_vector[s]);
50 [ + + ]: 4249198 : local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
51 : 2124599 : local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
52 : 2124599 : local_check(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
53 : : }
54 : : // local_check(realtype(pre_vector) == real_vector);
55 : 268903 : local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
56 [ + + ]: 537806 : local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
57 : 268903 : size_t pos = 0;
58 [ + + + + ]: 2662405 : for (const T& v : pre_vector) {
59 : 2124599 : local_check(v == real_vector[pos++]);
60 : : }
61 [ + + ]: 2393502 : for (const T& v : pre_vector | std::views::reverse) {
62 : 2124599 : local_check(v == real_vector[--pos]);
63 : : }
64 [ + + ]: 2393502 : for (const T& v : const_pre_vector) {
65 : 2124599 : local_check(v == real_vector[pos++]);
66 : : }
67 [ + + ]: 2393502 : for (const T& v : const_pre_vector | std::views::reverse) {
68 : 2124599 : local_check(v == real_vector[--pos]);
69 : : }
70 : 268903 : DataStream ss1{};
71 : 268903 : DataStream ss2{};
72 [ + - ]: 268903 : ss1 << real_vector;
73 [ + - ]: 537806 : ss2 << pre_vector;
74 : 268903 : local_check_equal(ss1.size(), ss2.size());
75 [ + + ]: 9036202 : for (Size s = 0; s < ss1.size(); s++) {
76 : 8767299 : local_check_equal(ss1[s], ss2[s]);
77 : : }
78 : 268903 : }
79 : :
80 : : public:
81 : 16296 : void resize(Size s)
82 : : {
83 : 16296 : real_vector.resize(s);
84 : 16296 : local_check_equal(real_vector.size(), s);
85 : 16296 : pre_vector.resize(s);
86 [ + + ]: 16296 : local_check_equal(pre_vector.size(), s);
87 : 16296 : test();
88 : 16296 : }
89 : :
90 : 4046 : void reserve(Size s)
91 : : {
92 : 4046 : real_vector.reserve(s);
93 : 4046 : local_check(real_vector.capacity() >= s);
94 : 4046 : pre_vector.reserve(s);
95 [ + + ]: 4046 : local_check(pre_vector.capacity() >= s);
96 : 4046 : test();
97 : 4046 : }
98 : :
99 : 32756 : void insert(Size position, const T& value)
100 : : {
101 : 32756 : real_vector.insert(real_vector.begin() + position, value);
102 [ + + ]: 65512 : pre_vector.insert(pre_vector.begin() + position, value);
103 : 32756 : test();
104 : 32756 : }
105 : :
106 : 16609 : void insert(Size position, Size count, const T& value)
107 : : {
108 : 16609 : real_vector.insert(real_vector.begin() + position, count, value);
109 [ + + ]: 33218 : pre_vector.insert(pre_vector.begin() + position, count, value);
110 : 16609 : test();
111 : 16609 : }
112 : :
113 : : template <typename I>
114 : 4190 : void insert_range(Size position, I first, I last)
115 : : {
116 : 4190 : real_vector.insert(real_vector.begin() + position, first, last);
117 [ + + ]: 8380 : pre_vector.insert(pre_vector.begin() + position, first, last);
118 : 4190 : test();
119 : 4190 : }
120 : :
121 : 27952 : void erase(Size position)
122 : : {
123 : 27952 : real_vector.erase(real_vector.begin() + position);
124 [ + + ]: 55904 : pre_vector.erase(pre_vector.begin() + position);
125 : 27952 : test();
126 : 27952 : }
127 : :
128 : 20249 : void erase(Size first, Size last)
129 : : {
130 : 20249 : real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
131 [ + + ]: 40498 : pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
132 : 20249 : test();
133 : 20249 : }
134 : :
135 : 109126 : void update(Size pos, const T& value)
136 : : {
137 [ + + ]: 109126 : real_vector[pos] = value;
138 [ + + ]: 109126 : pre_vector[pos] = value;
139 : 109126 : test();
140 : 109126 : }
141 : :
142 : 8237 : void push_back(const T& value)
143 : : {
144 : 8237 : real_vector.push_back(value);
145 : 8237 : pre_vector.push_back(value);
146 : 8237 : test();
147 : 8237 : }
148 : :
149 : 6842 : void pop_back()
150 : : {
151 : 6842 : real_vector.pop_back();
152 : 6842 : pre_vector.pop_back();
153 : 6842 : test();
154 : 6842 : }
155 : :
156 : 112 : void clear()
157 : : {
158 [ + + ]: 112 : real_vector.clear();
159 : 112 : pre_vector.clear();
160 : 112 : }
161 : :
162 : 296 : void assign(Size n, const T& value)
163 : : {
164 : 296 : real_vector.assign(n, value);
165 : 296 : pre_vector.assign(n, value);
166 : 296 : }
167 : :
168 : 640643 : Size size() const
169 : : {
170 : 640643 : return real_vector.size();
171 : : }
172 : :
173 : : Size capacity() const
174 : : {
175 : : return pre_vector.capacity();
176 : : }
177 : :
178 : 2035 : void shrink_to_fit()
179 : : {
180 : 2035 : pre_vector.shrink_to_fit();
181 [ + - ]: 2035 : test();
182 : 2035 : }
183 : :
184 : 16452 : void swap() noexcept
185 : : {
186 : 16452 : real_vector.swap(real_vector_alt);
187 : 16452 : pre_vector.swap(pre_vector_alt);
188 : 16452 : test();
189 : 16452 : }
190 : :
191 : 4144 : void move()
192 : : {
193 : 4144 : real_vector = std::move(real_vector_alt);
194 [ - + ]: 4144 : real_vector_alt.clear();
195 : 4144 : pre_vector = std::move(pre_vector_alt);
196 : 4144 : pre_vector_alt.clear();
197 : 4144 : }
198 : :
199 : 8274 : void copy()
200 : : {
201 : 8274 : real_vector = real_vector_alt;
202 : 8274 : pre_vector = pre_vector_alt;
203 : 8274 : }
204 : :
205 [ + + ]: 4113 : void resize_uninitialized(realtype values)
206 : : {
207 : 4113 : size_t r = values.size();
208 : 4113 : size_t s = real_vector.size() / 2;
209 [ + + ]: 4113 : if (real_vector.capacity() < s + r) {
210 : 1358 : real_vector.reserve(s + r);
211 : : }
212 : 4113 : real_vector.resize(s);
213 : 4113 : pre_vector.resize_uninitialized(s);
214 [ + + ]: 38144 : for (auto v : values) {
215 : 34031 : real_vector.push_back(v);
216 : : }
217 [ + + ]: 4113 : auto p = pre_vector.size();
218 : 4113 : pre_vector.resize_uninitialized(p + r);
219 [ + + ]: 38144 : for (auto v : values) {
220 [ + + ]: 34031 : pre_vector[p] = v;
221 : 34031 : ++p;
222 : : }
223 : 4113 : test();
224 : 4113 : }
225 : :
226 : 64 : ~prevector_tester()
227 : : {
228 [ - + ]: 64 : BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString());
229 : 64 : }
230 : :
231 : 64 : prevector_tester(FastRandomContext& rng)
232 : 64 : {
233 : 64 : rand_seed = rng.rand256();
234 : 64 : rng.Reseed(rand_seed);
235 : 64 : }
236 : : };
237 : :
238 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(PrevectorTestInt)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
239 : : {
240 [ + + ]: 65 : for (int j = 0; j < 64; j++) {
241 : 64 : prevector_tester<8, int> test{m_rng};
242 [ + + ]: 131136 : for (int i = 0; i < 2048; i++) {
243 [ + + ]: 131072 : if (m_rng.randbits(2) == 0) {
244 [ + - ]: 32756 : test.insert(m_rng.randrange(test.size() + 1), int(m_rng.rand32()));
245 : : }
246 [ + + + + ]: 131072 : if (test.size() > 0 && m_rng.randbits(2) == 1) {
247 [ + - ]: 27952 : test.erase(m_rng.randrange(test.size()));
248 : : }
249 [ + + ]: 131072 : if (m_rng.randbits(3) == 2) {
250 [ + + + + ]: 48746 : int new_size = std::max(0, std::min(30, (int)test.size() + (int)m_rng.randrange(5) - 2));
251 [ + - ]: 16296 : test.resize(new_size);
252 : : }
253 [ + + ]: 131072 : if (m_rng.randbits(3) == 3) {
254 [ + - ]: 16609 : test.insert(m_rng.randrange(test.size() + 1), 1 + m_rng.randbool(), int(m_rng.rand32()));
255 : : }
256 [ + + ]: 131072 : if (m_rng.randbits(3) == 4) {
257 [ + + ]: 16146 : int del = std::min<int>(test.size(), 1 + (m_rng.randbool()));
258 : 16146 : int beg = m_rng.randrange(test.size() + 1 - del);
259 [ + - ]: 16146 : test.erase(beg, beg + del);
260 : : }
261 [ + + ]: 131072 : if (m_rng.randbits(4) == 5) {
262 [ + - ]: 8237 : test.push_back(int(m_rng.rand32()));
263 : : }
264 [ + + + + ]: 131072 : if (test.size() > 0 && m_rng.randbits(4) == 6) {
265 [ + - ]: 6842 : test.pop_back();
266 : : }
267 [ + + ]: 131072 : if (m_rng.randbits(5) == 7) {
268 : 4190 : int values[4];
269 : 4190 : int num = 1 + (m_rng.randbits(2));
270 [ + + ]: 14595 : for (int k = 0; k < num; k++) {
271 : 10405 : values[k] = int(m_rng.rand32());
272 : : }
273 [ + - ]: 4190 : test.insert_range(m_rng.randrange(test.size() + 1), values, values + num);
274 : : }
275 [ + + ]: 131072 : if (m_rng.randbits(5) == 8) {
276 [ + + ]: 4103 : int del = std::min<int>(test.size(), 1 + (m_rng.randbits(2)));
277 : 4103 : int beg = m_rng.randrange(test.size() + 1 - del);
278 [ + - ]: 4103 : test.erase(beg, beg + del);
279 : : }
280 [ + + ]: 131072 : if (m_rng.randbits(5) == 9) {
281 [ + - ]: 4046 : test.reserve(m_rng.randbits(5));
282 : : }
283 [ + + ]: 131072 : if (m_rng.randbits(6) == 10) {
284 : 2035 : test.shrink_to_fit();
285 : : }
286 [ + + ]: 131072 : if (test.size() > 0) {
287 [ + - ]: 109126 : test.update(m_rng.randrange(test.size()), int(m_rng.rand32()));
288 : : }
289 [ + + ]: 131072 : if (m_rng.randbits(10) == 11) {
290 : 112 : test.clear();
291 : : }
292 [ + + ]: 131072 : if (m_rng.randbits(9) == 12) {
293 [ + - ]: 296 : test.assign(m_rng.randbits(5), int(m_rng.rand32()));
294 : : }
295 [ + + ]: 131072 : if (m_rng.randbits(3) == 3) {
296 : 16452 : test.swap();
297 : : }
298 [ + + ]: 131072 : if (m_rng.randbits(4) == 8) {
299 [ + - ]: 8274 : test.copy();
300 : : }
301 [ + + ]: 131072 : if (m_rng.randbits(5) == 18) {
302 : 4144 : test.move();
303 : : }
304 [ + + ]: 131072 : if (m_rng.randbits(5) == 19) {
305 : 4113 : unsigned int num = 1 + (m_rng.randbits(4));
306 [ + - ]: 4113 : std::vector<int> values(num);
307 [ + + ]: 38144 : for (int& v : values) {
308 : 34031 : v = int(m_rng.rand32());
309 : : }
310 [ + - + - ]: 8226 : test.resize_uninitialized(values);
311 : 4113 : }
312 : : }
313 : 64 : }
314 : 1 : }
315 : :
316 : : BOOST_AUTO_TEST_SUITE_END()
|
