/src/immer/extra/fuzzer/flex-vector.cpp
Line | Count | Source |
1 | | // |
2 | | // immer: immutable data structures for C++ |
3 | | // Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente |
4 | | // |
5 | | // This software is distributed under the Boost Software License, Version 1.0. |
6 | | // See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt |
7 | | // |
8 | | |
9 | | #include "fuzzer_input.hpp" |
10 | | |
11 | | #include <immer/box.hpp> |
12 | | #include <immer/flex_vector.hpp> |
13 | | |
14 | | #include <array> |
15 | | |
16 | | extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, |
17 | | std::size_t size) |
18 | 9.26k | { |
19 | 9.26k | constexpr auto var_count = 8; |
20 | 9.26k | constexpr auto bits = 2; |
21 | | |
22 | 9.26k | using vector_t = |
23 | 9.26k | immer::flex_vector<int, immer::default_memory_policy, bits, bits>; |
24 | 9.26k | using size_t = std::uint8_t; |
25 | | |
26 | 9.26k | auto vars = std::array<vector_t, var_count>{}; |
27 | | |
28 | 5.04M | auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; |
29 | 338k | auto is_valid_var_neq = [](auto other) { |
30 | 377k | return [=](auto idx) { |
31 | 377k | return idx >= 0 && idx < var_count && idx != other; |
32 | 377k | }; |
33 | 338k | }; |
34 | 204k | auto is_valid_index = [](auto& v) { |
35 | 221k | return [&](auto idx) { return idx >= 0 && idx < v.size(); }; |
36 | 204k | }; |
37 | 102k | auto is_valid_size = [](auto& v) { |
38 | 111k | return [&](auto idx) { return idx >= 0 && idx <= v.size(); }; |
39 | 102k | }; |
40 | 1.17M | auto can_concat = [](auto&& v1, auto&& v2) { |
41 | 1.17M | return v1.size() + v2.size() < vector_t::max_size(); |
42 | 1.17M | }; |
43 | 33.2k | auto can_compare = [](auto&& v) { |
44 | | // avoid comparing vectors that are too big, and hence, slow to compare |
45 | 33.2k | return v.size() < (1 << 15); |
46 | 33.2k | }; |
47 | 1.94M | return fuzzer_input{data, size}.run([&](auto& in) { |
48 | 1.94M | enum ops |
49 | 1.94M | { |
50 | 1.94M | op_push_back, |
51 | 1.94M | op_update, |
52 | 1.94M | op_take, |
53 | 1.94M | op_drop, |
54 | 1.94M | op_concat, |
55 | 1.94M | op_push_back_move, |
56 | 1.94M | op_update_move, |
57 | 1.94M | op_take_move, |
58 | 1.94M | op_drop_move, |
59 | 1.94M | op_concat_move_l, |
60 | 1.94M | op_concat_move_r, |
61 | 1.94M | op_concat_move_lr, |
62 | 1.94M | op_insert, |
63 | 1.94M | op_erase, |
64 | 1.94M | op_compare, |
65 | 1.94M | }; |
66 | 1.94M | auto src = read<char>(in, is_valid_var); |
67 | 1.94M | auto dst = read<char>(in, is_valid_var); |
68 | 1.94M | switch (read<char>(in)) { |
69 | 381k | case op_push_back: { |
70 | 381k | vars[dst] = vars[src].push_back(42); |
71 | 381k | break; |
72 | 0 | } |
73 | 163k | case op_update: { |
74 | 163k | auto idx = read<size_t>(in, is_valid_index(vars[src])); |
75 | 163k | vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; }); |
76 | 163k | break; |
77 | 0 | } |
78 | 1.52k | case op_take: { |
79 | 1.52k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
80 | 1.52k | vars[dst] = vars[src].take(idx); |
81 | 1.52k | break; |
82 | 0 | } |
83 | 3.01k | case op_drop: { |
84 | 3.01k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
85 | 3.01k | vars[dst] = vars[src].drop(idx); |
86 | 3.01k | break; |
87 | 0 | } |
88 | 834k | case op_concat: { |
89 | 834k | auto src2 = read<char>(in, is_valid_var); |
90 | 834k | if (can_concat(vars[src], vars[src2])) |
91 | 791k | vars[dst] = vars[src] + vars[src2]; |
92 | 834k | break; |
93 | 0 | } |
94 | 10.6k | case op_push_back_move: { |
95 | 10.6k | vars[dst] = std::move(vars[src]).push_back(21); |
96 | 10.6k | break; |
97 | 0 | } |
98 | 37.9k | case op_update_move: { |
99 | 37.9k | auto idx = read<size_t>(in, is_valid_index(vars[src])); |
100 | 37.9k | vars[dst] = |
101 | 37.9k | std::move(vars[src]).update(idx, [](auto x) { return x + 1; }); |
102 | 37.9k | break; |
103 | 0 | } |
104 | 37.5k | case op_take_move: { |
105 | 37.5k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
106 | 37.5k | vars[dst] = std::move(vars[src]).take(idx); |
107 | 37.5k | break; |
108 | 0 | } |
109 | 40.9k | case op_drop_move: { |
110 | 40.9k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
111 | 40.9k | vars[dst] = std::move(vars[src]).drop(idx); |
112 | 40.9k | break; |
113 | 0 | } |
114 | 332k | case op_concat_move_l: { |
115 | 332k | auto src2 = read<char>(in, is_valid_var_neq(src)); |
116 | 332k | if (can_concat(vars[src], vars[src2])) |
117 | 325k | vars[dst] = std::move(vars[src]) + vars[src2]; |
118 | 332k | break; |
119 | 0 | } |
120 | 4.46k | case op_concat_move_r: { |
121 | 4.46k | auto src2 = read<char>(in, is_valid_var_neq(src)); |
122 | 4.46k | if (can_concat(vars[src], vars[src2])) |
123 | 3.80k | vars[dst] = vars[src] + std::move(vars[src2]); |
124 | 4.46k | break; |
125 | 0 | } |
126 | 2.14k | case op_concat_move_lr: { |
127 | 2.14k | auto src2 = read<char>(in, is_valid_var_neq(src)); |
128 | 2.14k | if (can_concat(vars[src], vars[src2])) |
129 | 1.50k | vars[dst] = std::move(vars[src]) + std::move(vars[src2]); |
130 | 2.14k | break; |
131 | 0 | } |
132 | 33.2k | case op_compare: { |
133 | 33.2k | using std::swap; |
134 | 33.2k | if (can_compare(vars[src]) && vars[src] == vars[dst]) |
135 | 8.60k | swap(vars[src], vars[dst]); |
136 | 33.2k | break; |
137 | 0 | } |
138 | 3.00k | case op_erase: { |
139 | 3.00k | auto idx = read<size_t>(in, is_valid_index(vars[src])); |
140 | 3.00k | vars[dst] = vars[src].erase(idx); |
141 | 3.00k | break; |
142 | 0 | } |
143 | 19.4k | case op_insert: { |
144 | 19.4k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
145 | 19.4k | vars[dst] = vars[src].insert(idx, immer::box<int>{42}); |
146 | 19.4k | break; |
147 | 0 | } |
148 | 34.3k | default: |
149 | 34.3k | break; |
150 | 1.94M | }; |
151 | 1.93M | return true; |
152 | 1.94M | }); |
153 | 9.26k | } |