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 : :
7 : : #include <serialize.h>
8 : : #include <streams.h>
9 : : #include <test/fuzz/FuzzedDataProvider.h>
10 : : #include <test/fuzz/fuzz.h>
11 : : #include <util/check.h>
12 : :
13 : : #include <ranges>
14 : : #include <vector>
15 : : namespace {
16 : :
17 : : template <unsigned int N, typename T>
18 : : class prevector_tester
19 : : {
20 : : typedef std::vector<T> realtype;
21 : : realtype real_vector;
22 : : realtype real_vector_alt;
23 : :
24 : : typedef prevector<N, T> pretype;
25 : : pretype pre_vector;
26 : : pretype pre_vector_alt;
27 : :
28 : : typedef typename pretype::size_type Size;
29 : :
30 : : public:
31 : 249 : void test() const
32 : : {
33 : 249 : const pretype& const_pre_vector = pre_vector;
34 [ - + + + : 415 : assert(real_vector.size() == pre_vector.size());
- + ]
35 [ - + ]: 249 : assert(real_vector.empty() == pre_vector.empty());
36 [ + + ]: 760605 : for (Size s = 0; s < real_vector.size(); s++) {
37 [ + + - + ]: 1520712 : assert(real_vector[s] == pre_vector[s]);
38 [ + + - + ]: 1520712 : assert(&(pre_vector[s]) == &(pre_vector.begin()[s]));
39 [ - + ]: 760356 : assert(&(pre_vector[s]) == &*(pre_vector.begin() + s));
40 [ - + ]: 760356 : assert(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
41 : : }
42 : : // assert(realtype(pre_vector) == real_vector);
43 [ - + ]: 249 : assert(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
44 [ + + - + ]: 498 : assert(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
45 : 249 : size_t pos = 0;
46 [ + + + + ]: 760854 : for (const T& v : pre_vector) {
47 [ - + ]: 760356 : assert(v == real_vector[pos]);
48 : 760356 : ++pos;
49 : : }
50 [ + + ]: 760605 : for (const T& v : pre_vector | std::views::reverse) {
51 : 760356 : --pos;
52 [ - + ]: 760356 : assert(v == real_vector[pos]);
53 : : }
54 [ + + ]: 760605 : for (const T& v : const_pre_vector) {
55 [ - + ]: 760356 : assert(v == real_vector[pos]);
56 : 760356 : ++pos;
57 : : }
58 [ + + ]: 760605 : for (const T& v : const_pre_vector | std::views::reverse) {
59 : 760356 : --pos;
60 [ - + ]: 760356 : assert(v == real_vector[pos]);
61 : : }
62 : 249 : DataStream ss1{};
63 : 249 : DataStream ss2{};
64 [ + - ]: 249 : ss1 << real_vector;
65 [ + - - + ]: 498 : ss2 << pre_vector;
66 [ - + - + ]: 249 : assert(ss1.size() == ss2.size());
67 [ + + ]: 3042016 : for (Size s = 0; s < ss1.size(); s++) {
68 [ - + ]: 3041767 : assert(ss1[s] == ss2[s]);
69 : : }
70 : 249 : }
71 : :
72 : 13111 : void resize(Size s)
73 : : {
74 : 13111 : real_vector.resize(s);
75 [ - + - + ]: 13111 : assert(real_vector.size() == s);
76 : 13111 : pre_vector.resize(s);
77 [ + + - + ]: 19110 : assert(pre_vector.size() == s);
78 : 13111 : }
79 : :
80 : 6706 : void reserve(Size s)
81 : : {
82 : 6706 : real_vector.reserve(s);
83 [ - + - + ]: 6706 : assert(real_vector.capacity() >= s);
84 : 6706 : pre_vector.reserve(s);
85 [ + + - + ]: 12913 : assert(pre_vector.capacity() >= s);
86 : 6706 : }
87 : :
88 : 19816 : void insert(Size position, const T& value)
89 : : {
90 : 19816 : real_vector.insert(real_vector.begin() + position, value);
91 [ + + ]: 39632 : pre_vector.insert(pre_vector.begin() + position, value);
92 : 19816 : }
93 : :
94 : 17064 : void insert(Size position, Size count, const T& value)
95 : : {
96 : 17064 : real_vector.insert(real_vector.begin() + position, count, value);
97 [ + + ]: 34128 : pre_vector.insert(pre_vector.begin() + position, count, value);
98 : 17064 : }
99 : :
100 : : template <typename I>
101 : 10568 : void insert_range(Size position, I first, I last)
102 : : {
103 : 10568 : real_vector.insert(real_vector.begin() + position, first, last);
104 [ + + ]: 21136 : pre_vector.insert(pre_vector.begin() + position, first, last);
105 : 10568 : }
106 : :
107 : 4402 : void erase(Size position)
108 : : {
109 : 4402 : real_vector.erase(real_vector.begin() + position);
110 [ + + ]: 8804 : pre_vector.erase(pre_vector.begin() + position);
111 : 4402 : }
112 : :
113 : 8471 : void erase(Size first, Size last)
114 : : {
115 : 8471 : real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
116 [ + + ]: 16942 : pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
117 : 8471 : }
118 : :
119 : 4047 : void update(Size pos, const T& value)
120 : : {
121 [ + + ]: 4047 : real_vector[pos] = value;
122 [ + + ]: 4047 : pre_vector[pos] = value;
123 : 4047 : }
124 : :
125 : 6338 : void push_back(const T& value)
126 : : {
127 : 6338 : real_vector.push_back(value);
128 : 6338 : pre_vector.push_back(value);
129 : 6338 : }
130 : :
131 : 7006 : void pop_back()
132 : : {
133 : 7006 : real_vector.pop_back();
134 : 7006 : pre_vector.pop_back();
135 : 7006 : }
136 : :
137 : 7212 : void clear()
138 : : {
139 [ + + ]: 7212 : real_vector.clear();
140 : 7212 : pre_vector.clear();
141 : 7212 : }
142 : :
143 : 14046 : void assign(Size n, const T& value)
144 : : {
145 : 14046 : real_vector.assign(n, value);
146 : 14046 : pre_vector.assign(n, value);
147 : 14046 : }
148 : :
149 : 265422 : Size size() const
150 : : {
151 : 530844 : return real_vector.size();
152 : : }
153 : :
154 : : Size capacity() const
155 : : {
156 : : return pre_vector.capacity();
157 : : }
158 : :
159 : 12318 : void shrink_to_fit()
160 : : {
161 : 12318 : pre_vector.shrink_to_fit();
162 : 12318 : }
163 : :
164 : 9616 : void swap() noexcept
165 : : {
166 : 9616 : real_vector.swap(real_vector_alt);
167 : 9616 : pre_vector.swap(pre_vector_alt);
168 : 9616 : }
169 : :
170 : 17293 : void move()
171 : : {
172 : 17293 : real_vector = std::move(real_vector_alt);
173 [ - + ]: 17293 : real_vector_alt.clear();
174 : 17293 : pre_vector = std::move(pre_vector_alt);
175 : 17293 : pre_vector_alt.clear();
176 : 17293 : }
177 : :
178 : 17345 : void copy()
179 : : {
180 : 17345 : real_vector = real_vector_alt;
181 : 17345 : pre_vector = pre_vector_alt;
182 : 17345 : }
183 : :
184 [ - + ]: 4113 : void resize_uninitialized(realtype values)
185 : : {
186 : 4113 : size_t r = values.size();
187 [ - + ]: 4113 : size_t s = real_vector.size() / 2;
188 [ - + + + ]: 4113 : if (real_vector.capacity() < s + r) {
189 : 1657 : real_vector.reserve(s + r);
190 : : }
191 : 4113 : real_vector.resize(s);
192 : 4113 : pre_vector.resize_uninitialized(s);
193 [ + + ]: 32523 : for (auto v : values) {
194 : 28410 : real_vector.push_back(v);
195 : : }
196 [ + + ]: 4113 : auto p = pre_vector.size();
197 : 4113 : pre_vector.resize_uninitialized(p + r);
198 [ + + ]: 32523 : for (auto v : values) {
199 [ + + ]: 28410 : pre_vector[p] = v;
200 : 28410 : ++p;
201 : : }
202 : 4113 : }
203 : : };
204 : :
205 : : } // namespace
206 : :
207 [ + - ]: 725 : FUZZ_TARGET(prevector)
208 : : {
209 : 249 : FuzzedDataProvider prov(buffer.data(), buffer.size());
210 : 249 : prevector_tester<8, int> test;
211 : :
212 [ + + + + ]: 179721 : LIMITED_WHILE (prov.remaining_bytes(), 3000) {
213 : 227281 : switch (prov.ConsumeIntegralInRange<int>(0, 13 + 3 * (test.size() > 0))) {
[ + + + +
+ + + + +
+ + + + +
+ + + + +
- - + ]
214 : 19816 : case 0: {
215 [ - + ]: 19816 : auto position = prov.ConsumeIntegralInRange<size_t>(0, test.size());
216 : 19816 : auto value = prov.ConsumeIntegral<int>();
217 [ + - ]: 19816 : test.insert(position, value);
218 : : } break;
219 : 13111 : case 1:
220 [ - + + + : 35676 : test.resize(std::max(0, std::min(30, (int)test.size() + prov.ConsumeIntegralInRange<int>(0, 4) - 2)));
+ + + - ]
221 : : break;
222 : 17064 : case 2: {
223 [ - + ]: 17064 : auto position = prov.ConsumeIntegralInRange<size_t>(0, test.size());
224 : 17064 : auto count = 1 + prov.ConsumeBool();
225 : 17064 : auto value = prov.ConsumeIntegral<int>();
226 [ + - ]: 17064 : test.insert(position, count, value);
227 : : } break;
228 : 8471 : case 3: {
229 [ - + ]: 8471 : int del = prov.ConsumeIntegralInRange<int>(0, test.size());
230 [ - + ]: 8471 : int beg = prov.ConsumeIntegralInRange<int>(0, test.size() - del);
231 : 8471 : test.erase(beg, beg + del);
232 : : break;
233 : : }
234 : 6338 : case 4:
235 [ + - ]: 6338 : test.push_back(prov.ConsumeIntegral<int>());
236 : : break;
237 : 10568 : case 5: {
238 : 10568 : int values[4];
239 : 10568 : int num = 1 + prov.ConsumeIntegralInRange<int>(0, 3);
240 [ + + ]: 33330 : for (int k = 0; k < num; ++k) {
241 : 22762 : values[k] = prov.ConsumeIntegral<int>();
242 : : }
243 [ - + + - ]: 10568 : test.insert_range(prov.ConsumeIntegralInRange<size_t>(0, test.size()), values, values + num);
244 : : break;
245 : : }
246 : 4113 : case 6: {
247 : 4113 : int num = 1 + prov.ConsumeIntegralInRange<int>(0, 15);
248 [ + - ]: 4113 : std::vector<int> values(num);
249 [ + + ]: 32523 : for (auto& v : values) {
250 : 28410 : v = prov.ConsumeIntegral<int>();
251 : : }
252 [ + - + - ]: 4113 : test.resize_uninitialized(values);
253 : 4113 : break;
254 : 4113 : }
255 : 6706 : case 7:
256 [ + - ]: 6706 : test.reserve(prov.ConsumeIntegralInRange<size_t>(0, 32767));
257 : : break;
258 : 12318 : case 8:
259 : 12318 : test.shrink_to_fit();
260 : : break;
261 : 7212 : case 9:
262 : 7212 : test.clear();
263 : : break;
264 : 14046 : case 10: {
265 : 14046 : auto n = prov.ConsumeIntegralInRange<size_t>(0, 32767);
266 : 14046 : auto value = prov.ConsumeIntegral<int>();
267 [ + - ]: 14046 : test.assign(n, value);
268 : : } break;
269 : 9616 : case 11:
270 : 9616 : test.swap();
271 : 9616 : break;
272 : 17345 : case 12:
273 [ + - ]: 17345 : test.copy();
274 : : break;
275 : 17293 : case 13:
276 : 17293 : test.move();
277 : : break;
278 : 4047 : case 14: {
279 [ - + ]: 4047 : auto pos = prov.ConsumeIntegralInRange<size_t>(0, test.size() - 1);
280 : 4047 : auto value = prov.ConsumeIntegral<int>();
281 : 4047 : test.update(pos, value);
282 : : } break;
283 : 4402 : case 15:
284 [ - + ]: 4402 : test.erase(prov.ConsumeIntegralInRange<size_t>(0, test.size() - 1));
285 : : break;
286 : 7006 : case 16:
287 : 7006 : test.pop_back();
288 : : break;
289 : : }
290 : : }
291 : :
292 [ + - ]: 249 : test.test();
293 : 249 : }
|