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