/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 | 8.74k | { |
19 | 8.74k | constexpr auto var_count = 8; |
20 | 8.74k | constexpr auto bits = 2; |
21 | | |
22 | 8.74k | using vector_t = |
23 | 8.74k | immer::flex_vector<int, immer::default_memory_policy, bits, bits>; |
24 | 8.74k | using size_t = std::uint8_t; |
25 | | |
26 | 8.74k | auto vars = std::array<vector_t, var_count>{}; |
27 | | |
28 | 5.17M | auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; |
29 | 277k | auto is_valid_var_neq = [](auto other) { |
30 | 324k | return [=](auto idx) { |
31 | 324k | return idx >= 0 && idx < var_count && idx != other; |
32 | 324k | }; |
33 | 277k | }; |
34 | 191k | auto is_valid_index = [](auto& v) { |
35 | 346k | return [&](auto idx) { return idx >= 0 && idx < v.size(); }; |
36 | 191k | }; |
37 | 108k | auto is_valid_size = [](auto& v) { |
38 | 121k | return [&](auto idx) { return idx >= 0 && idx <= v.size(); }; |
39 | 108k | }; |
40 | 1.14M | auto can_concat = [](auto&& v1, auto&& v2) { |
41 | 1.14M | return v1.size() + v2.size() < vector_t::max_size(); |
42 | 1.14M | }; |
43 | 31.3k | auto can_compare = [](auto&& v) { |
44 | | // avoid comparing vectors that are too big, and hence, slow to compare |
45 | 31.3k | return v.size() < (1 << 15); |
46 | 31.3k | }; |
47 | 1.98M | return fuzzer_input{data, size}.run([&](auto& in) { |
48 | 1.98M | enum ops |
49 | 1.98M | { |
50 | 1.98M | op_push_back, |
51 | 1.98M | op_update, |
52 | 1.98M | op_take, |
53 | 1.98M | op_drop, |
54 | 1.98M | op_concat, |
55 | 1.98M | op_push_back_move, |
56 | 1.98M | op_update_move, |
57 | 1.98M | op_take_move, |
58 | 1.98M | op_drop_move, |
59 | 1.98M | op_concat_move_l, |
60 | 1.98M | op_concat_move_r, |
61 | 1.98M | op_concat_move_lr, |
62 | 1.98M | op_insert, |
63 | 1.98M | op_erase, |
64 | 1.98M | op_compare, |
65 | 1.98M | }; |
66 | 1.98M | auto src = read<char>(in, is_valid_var); |
67 | 1.98M | auto dst = read<char>(in, is_valid_var); |
68 | 1.98M | switch (read<char>(in)) { |
69 | 464k | case op_push_back: { |
70 | 464k | vars[dst] = vars[src].push_back(42); |
71 | 464k | break; |
72 | 0 | } |
73 | 119k | case op_update: { |
74 | 119k | auto idx = read<size_t>(in, is_valid_index(vars[src])); |
75 | 119k | vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; }); |
76 | 119k | break; |
77 | 0 | } |
78 | 1.60k | case op_take: { |
79 | 1.60k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
80 | 1.60k | vars[dst] = vars[src].take(idx); |
81 | 1.60k | break; |
82 | 0 | } |
83 | 3.19k | case op_drop: { |
84 | 3.19k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
85 | 3.19k | vars[dst] = vars[src].drop(idx); |
86 | 3.19k | break; |
87 | 0 | } |
88 | 865k | case op_concat: { |
89 | 865k | auto src2 = read<char>(in, is_valid_var); |
90 | 865k | if (can_concat(vars[src], vars[src2])) |
91 | 812k | vars[dst] = vars[src] + vars[src2]; |
92 | 865k | break; |
93 | 0 | } |
94 | 12.4k | case op_push_back_move: { |
95 | 12.4k | vars[dst] = std::move(vars[src]).push_back(21); |
96 | 12.4k | break; |
97 | 0 | } |
98 | 67.9k | case op_update_move: { |
99 | 67.9k | auto idx = read<size_t>(in, is_valid_index(vars[src])); |
100 | 67.9k | vars[dst] = |
101 | 67.9k | std::move(vars[src]).update(idx, [](auto x) { return x + 1; }); |
102 | 67.9k | break; |
103 | 0 | } |
104 | 41.5k | case op_take_move: { |
105 | 41.5k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
106 | 41.5k | vars[dst] = std::move(vars[src]).take(idx); |
107 | 41.5k | break; |
108 | 0 | } |
109 | 43.0k | case op_drop_move: { |
110 | 43.0k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
111 | 43.0k | vars[dst] = std::move(vars[src]).drop(idx); |
112 | 43.0k | break; |
113 | 0 | } |
114 | 270k | case op_concat_move_l: { |
115 | 270k | auto src2 = read<char>(in, is_valid_var_neq(src)); |
116 | 270k | if (can_concat(vars[src], vars[src2])) |
117 | 263k | vars[dst] = std::move(vars[src]) + vars[src2]; |
118 | 270k | break; |
119 | 0 | } |
120 | 4.10k | case op_concat_move_r: { |
121 | 4.10k | auto src2 = read<char>(in, is_valid_var_neq(src)); |
122 | 4.10k | if (can_concat(vars[src], vars[src2])) |
123 | 3.65k | vars[dst] = vars[src] + std::move(vars[src2]); |
124 | 4.10k | break; |
125 | 0 | } |
126 | 2.31k | case op_concat_move_lr: { |
127 | 2.31k | auto src2 = read<char>(in, is_valid_var_neq(src)); |
128 | 2.31k | if (can_concat(vars[src], vars[src2])) |
129 | 1.69k | vars[dst] = std::move(vars[src]) + std::move(vars[src2]); |
130 | 2.31k | break; |
131 | 0 | } |
132 | 31.3k | case op_compare: { |
133 | 31.3k | using std::swap; |
134 | 31.3k | if (can_compare(vars[src]) && vars[src] == vars[dst]) |
135 | 6.34k | swap(vars[src], vars[dst]); |
136 | 31.3k | break; |
137 | 0 | } |
138 | 3.55k | case op_erase: { |
139 | 3.55k | auto idx = read<size_t>(in, is_valid_index(vars[src])); |
140 | 3.55k | vars[dst] = vars[src].erase(idx); |
141 | 3.55k | break; |
142 | 0 | } |
143 | 19.5k | case op_insert: { |
144 | 19.5k | auto idx = read<size_t>(in, is_valid_size(vars[src])); |
145 | 19.5k | vars[dst] = vars[src].insert(idx, immer::box<int>{42}); |
146 | 19.5k | break; |
147 | 0 | } |
148 | 27.8k | default: |
149 | 27.8k | break; |
150 | 1.98M | }; |
151 | 1.97M | return true; |
152 | 1.98M | }); |
153 | 8.74k | } |