15 constexpr
int LEN_BITS = 16;
16 constexpr
int RANDDATA_BITS = 20;
21 std::vector<bool> RANDDATA;
27 for (
size_t i = 0; i < (1U << RANDDATA_BITS) + (1U << LEN_BITS); ++i) {
28 RANDDATA.push_back(ctx.randbool());
40 size_t limitlen = 4 * maxlen;
45 const auto& cdeq = deq;
46 const auto& cbitdeq = bitdeq;
52 bitdeq.push_back(val);
59 assert(deq.size() == bitdeq.size());
60 auto it = deq.begin();
61 auto bitit = bitdeq.begin();
62 auto itend = deq.end();
73 deq = std::deque<bool>{};
74 bitdeq = bitdeque_type{};
91 deq.assign(
count, val);
92 bitdeq.assign(
count, val);
98 deq = std::deque<bool>(
count, val);
99 bitdeq = bitdeque_type(
count, val);
104 deq = std::deque<bool>(
count);
105 bitdeq = bitdeque_type(
count);
110 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
111 auto rand_end = rand_begin +
count;
112 deq = std::deque<bool>(rand_begin, rand_end);
113 bitdeq = bitdeque_type(rand_begin, rand_end);
118 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
119 auto rand_end = rand_begin +
count;
120 deq.assign(rand_begin, rand_end);
121 bitdeq.assign(rand_begin, rand_end);
126 deq = std::deque<bool>(ilist);
127 bitdeq = bitdeque_type(ilist);
133 bitdeq.assign(ilist);
139 const std::deque<bool> deq2(
count, val);
141 const bitdeque_type bitdeq2(
count, val);
148 std::deque<bool> deq2(
count, val);
149 deq = std::move(deq2);
150 bitdeque_type bitdeq2(
count, val);
151 bitdeq = std::move(bitdeq2);
156 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
157 auto rand_end = rand_begin +
count;
158 std::deque<bool> deq2(rand_begin, rand_end);
159 bitdeque_type bitdeq2(rand_begin, rand_end);
161 assert(deq.size() == bitdeq.size());
162 assert(deq2.size() == bitdeq2.size());
164 swap(bitdeq, bitdeq2);
165 assert(deq.size() == bitdeq.size());
166 assert(deq2.size() == bitdeq2.size());
171 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
172 auto rand_end = rand_begin +
count;
173 std::deque<bool> deq2(rand_begin, rand_end);
174 bitdeque_type bitdeq2(rand_begin, rand_end);
175 assert(deq.size() == bitdeq.size());
176 assert(deq2.size() == bitdeq2.size());
178 bitdeq.swap(bitdeq2);
179 assert(deq.size() == bitdeq.size());
180 assert(deq2.size() == bitdeq2.size());
192 auto it = deq.begin() + pos1;
193 auto bitit = bitdeq.begin() + pos1;
194 if ((
size_t)pos1 != cdeq.size())
assert(*it == *bitit);
195 assert(it - deq.begin() == pos1);
196 assert(bitit - bitdeq.begin() == pos1);
199 bitit += pos2 - pos1;
202 bitit -= pos1 - pos2;
204 if ((
size_t)pos2 != cdeq.size())
assert(*it == *bitit);
205 assert(deq.end() - it == bitdeq.end() - bitit);
207 if ((
size_t)pos2 != cdeq.size()) {
217 assert(deq.end() - it == bitdeq.end() - bitit);
221 assert(deq.end() - deq.begin() == bitdeq.end() - bitdeq.begin());
225 assert(cdeq.end() - cdeq.begin() == cbitdeq.end() - cbitdeq.begin());
229 assert(deq.rend() - deq.rbegin() == bitdeq.rend() - bitdeq.rbegin());
233 assert(cdeq.rend() - cdeq.rbegin() == cbitdeq.rend() - cbitdeq.rbegin());
237 assert(cdeq.cend() - cdeq.cbegin() == cbitdeq.cend() - cbitdeq.cbegin());
241 assert(cdeq.crend() - cdeq.crbegin() == cbitdeq.crend() - cbitdeq.crbegin());
245 assert(cdeq.size() == cbitdeq.size());
246 assert(cbitdeq.size() <= cbitdeq.max_size());
250 assert(cdeq.empty() == cbitdeq.empty());
256 auto& ref = deq.at(pos);
257 auto bitref = bitdeq.at(pos);
269 bool throw_deq{
false}, throw_bitdeq{
false};
270 bool val_deq{
false}, val_bitdeq{
false};
272 auto& ref = deq.at(pos);
275 }
catch (
const std::out_of_range&) {
279 auto ref = bitdeq.at(pos);
282 }
catch (
const std::out_of_range&) {
285 assert(throw_deq == throw_bitdeq);
286 assert(throw_bitdeq == (pos >= cdeq.size()));
287 if (!throw_deq)
assert(val_deq == val_bitdeq);
292 bool throw_deq{
false}, throw_bitdeq{
false};
293 bool val_deq{
false}, val_bitdeq{
false};
295 auto& ref = cdeq.at(pos);
297 }
catch (
const std::out_of_range&) {
301 auto ref = cbitdeq.at(pos);
303 }
catch (
const std::out_of_range&) {
306 assert(throw_deq == throw_bitdeq);
307 assert(throw_bitdeq == (pos >= cdeq.size()));
308 if (!throw_deq)
assert(val_deq == val_bitdeq);
314 assert(deq[pos] == bitdeq[pos]);
316 deq[pos] = !deq[pos];
325 assert(deq[pos] == bitdeq[pos]);
331 auto& ref = deq.front();
332 auto bitref = bitdeq.front();
343 auto& ref = cdeq.front();
344 auto bitref = cbitdeq.front();
351 auto& ref = deq.back();
352 auto bitref = bitdeq.back();
363 const auto& cdeq = deq;
364 const auto& cbitdeq = bitdeq;
365 auto& ref = cdeq.back();
366 auto bitref = cbitdeq.back();
372 if (cdeq.size() < limitlen) {
376 bitdeq.push_back(val);
379 auto& ref = deq[pos];
380 auto bitref = bitdeq[pos];
383 bitdeq.push_back(val);
390 if (cdeq.size() < limitlen) {
394 bitdeq.push_front(val);
397 auto& ref = deq[pos];
398 auto bitref = bitdeq[pos];
401 bitdeq.push_front(val);
409 if (cdeq.size() == 1) {
414 auto& ref = deq[pos];
415 auto bitref = bitdeq[pos];
426 if (cdeq.size() == 1) {
431 auto& ref = deq[pos];
432 auto bitref = bitdeq[pos];
444 size_t after = cdeq.size() - 1 - before;
445 auto it = deq.erase(cdeq.begin() + before);
446 auto bitit = bitdeq.erase(cbitdeq.begin() + before);
447 assert(it == cdeq.begin() + before && it == cdeq.end() - after);
448 assert(bitit == cbitdeq.begin() + before && bitit == cbitdeq.end() - after);
454 auto it = deq.erase(cdeq.begin(), cdeq.begin() +
count);
455 auto bitit = bitdeq.erase(cbitdeq.begin(), cbitdeq.begin() +
count);
456 assert(it == deq.begin());
457 assert(bitit == bitdeq.begin());
462 auto it = deq.erase(cdeq.end() -
count, cdeq.end());
463 auto bitit = bitdeq.erase(cbitdeq.end() -
count, cbitdeq.end());
465 assert(bitit == bitdeq.end());
471 size_t after = cdeq.size() -
count - before;
472 auto it = deq.erase(cdeq.begin() + before, cdeq.end() - after);
473 auto bitit = bitdeq.erase(cbitdeq.begin() + before, cbitdeq.end() - after);
474 assert(it == cdeq.begin() + before && it == cdeq.end() - after);
475 assert(bitit == cbitdeq.begin() + before && bitit == cbitdeq.end() - after);
479 if (cdeq.size() < limitlen) {
483 auto it = deq.insert(cdeq.begin() + before, val);
484 auto bitit = do_emplace ? bitdeq.emplace(cbitdeq.begin() + before, val)
485 : bitdeq.insert(cbitdeq.begin() + before, val);
486 assert(it == deq.begin() + before);
487 assert(bitit == bitdeq.begin() + before);
492 if (cdeq.size() < limitlen) {
494 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
495 auto rand_end = rand_begin +
count;
496 auto it = deq.insert(cdeq.begin(), rand_begin, rand_end);
497 auto bitit = bitdeq.insert(cbitdeq.begin(), rand_begin, rand_end);
498 assert(it == cdeq.begin());
499 assert(bitit == cbitdeq.begin());
504 if (cdeq.size() < limitlen) {
506 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
507 auto rand_end = rand_begin +
count;
508 auto it = deq.insert(cdeq.end(), rand_begin, rand_end);
509 auto bitit = bitdeq.insert(cbitdeq.end(), rand_begin, rand_end);
516 if (cdeq.size() < limitlen) {
520 auto it = deq.insert(cdeq.begin() + before,
count, val);
521 auto bitit = bitdeq.insert(cbitdeq.begin() + before,
count, val);
522 assert(it == deq.begin() + before);
523 assert(bitit == bitdeq.begin() + before);
528 if (cdeq.size() < limitlen) {
531 auto rand_begin = RANDDATA.begin() + ctx.
randbits(RANDDATA_BITS);
532 auto rand_end = rand_begin +
count;
533 auto it = deq.insert(cdeq.begin() + before, rand_begin, rand_end);
534 auto bitit = bitdeq.insert(cbitdeq.begin() + before, rand_begin, rand_end);
535 assert(it == deq.begin() + before);
536 assert(bitit == bitdeq.begin() + before);
FUZZ_TARGET(bitdeque,.init=InitRandData)
bool randbool() noexcept
Generate a random boolean.
uint64_t randbits(int bits) noexcept
Generate a random (bits)-bit integer.
T ConsumeIntegralInRange(T min, T max)
Class that mimics std::deque<bool>, but with std::vector<bool>'s bit packing.
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
size_t CallOneOf(FuzzedDataProvider &fuzzed_data_provider, Callables... callables)