/src/immer/extra/fuzzer/map.cpp
Line | Count | Source (jump to first uncovered line) |
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/map.hpp> |
12 | | |
13 | | #include <immer/algorithm.hpp> |
14 | | |
15 | | #include <array> |
16 | | |
17 | | struct colliding_hash_t |
18 | | { |
19 | 4.26M | std::size_t operator()(std::size_t x) const { return x & ~15; } |
20 | | }; |
21 | | |
22 | | extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, |
23 | | std::size_t size) |
24 | 86.4k | { |
25 | 86.4k | constexpr auto var_count = 4; |
26 | | |
27 | 86.4k | using map_t = immer::map<std::size_t, int, colliding_hash_t>; |
28 | | |
29 | 86.4k | auto vars = std::array<map_t, var_count>{}; |
30 | | |
31 | 692k | auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; |
32 | | |
33 | 202k | return fuzzer_input{data, size}.run([&](auto& in) { |
34 | 202k | enum ops |
35 | 202k | { |
36 | 202k | op_set, |
37 | 202k | op_erase, |
38 | 202k | op_set_move, |
39 | 202k | op_erase_move, |
40 | 202k | op_iterate, |
41 | 202k | op_find, |
42 | 202k | op_update, |
43 | 202k | op_update_move, |
44 | 202k | op_update_if_exists, |
45 | 202k | op_update_if_exists_move, |
46 | 202k | op_diff, |
47 | 202k | }; |
48 | 202k | auto src = read<char>(in, is_valid_var); |
49 | 202k | auto dst = read<char>(in, is_valid_var); |
50 | 202k | switch (read<char>(in)) { |
51 | 83.3k | case op_set: { |
52 | 83.3k | auto value = read<size_t>(in); |
53 | 83.3k | vars[dst] = vars[src].set(value, 42); |
54 | 83.3k | break; |
55 | 0 | } |
56 | 13.7k | case op_erase: { |
57 | 13.7k | auto value = read<size_t>(in); |
58 | 13.7k | vars[dst] = vars[src].erase(value); |
59 | 13.7k | break; |
60 | 0 | } |
61 | 15.1k | case op_set_move: { |
62 | 15.1k | auto value = read<size_t>(in); |
63 | 15.1k | vars[dst] = std::move(vars[src]).set(value, 42); |
64 | 15.1k | break; |
65 | 0 | } |
66 | 10.5k | case op_erase_move: { |
67 | 10.5k | auto value = read<size_t>(in); |
68 | 10.5k | vars[dst] = std::move(vars[src]).erase(value); |
69 | 10.5k | break; |
70 | 0 | } |
71 | 9.11k | case op_iterate: { |
72 | 9.11k | auto srcv = vars[src]; |
73 | 518k | for (const auto& v : srcv) { |
74 | 518k | vars[dst] = vars[dst].set(v.first, v.second); |
75 | 518k | } |
76 | 9.11k | break; |
77 | 0 | } |
78 | 2.89k | case op_find: { |
79 | 2.89k | auto value = read<size_t>(in); |
80 | 2.89k | auto res = vars[src].find(value); |
81 | 2.89k | if (res != nullptr) { |
82 | 1.05k | vars[dst] = vars[dst].set(*res, 42); |
83 | 1.05k | } |
84 | 2.89k | break; |
85 | 0 | } |
86 | 5.35k | case op_update: { |
87 | 5.35k | auto key = read<size_t>(in); |
88 | 5.35k | vars[dst] = vars[src].update(key, [](int x) { return x + 1; }); |
89 | 5.35k | break; |
90 | 0 | } |
91 | 13.3k | case op_update_move: { |
92 | 13.3k | auto key = read<size_t>(in); |
93 | 13.3k | vars[dst] = |
94 | 13.3k | std::move(vars[src]).update(key, [](int x) { return x + 1; }); |
95 | 13.3k | break; |
96 | 0 | } |
97 | 7.92k | case op_update_if_exists: { |
98 | 7.92k | auto key = read<size_t>(in); |
99 | 7.92k | vars[dst] = |
100 | 7.92k | vars[src].update_if_exists(key, [](int x) { return x + 1; }); |
101 | 7.92k | break; |
102 | 0 | } |
103 | 7.53k | case op_update_if_exists_move: { |
104 | 7.53k | auto key = read<size_t>(in); |
105 | 7.53k | vars[dst] = std::move(vars[src]).update_if_exists( |
106 | 7.53k | key, [](int x) { return x + 1; }); |
107 | 7.53k | break; |
108 | 0 | } |
109 | 15.3k | case op_diff: { |
110 | 15.3k | auto&& a = vars[src]; |
111 | 15.3k | auto&& b = vars[dst]; |
112 | 15.3k | diff( |
113 | 15.3k | a, |
114 | 15.3k | b, |
115 | 51.3k | [&](auto&& x) { |
116 | 51.3k | assert(!a.count(x.first)); |
117 | 0 | assert(b.count(x.first)); |
118 | 51.3k | }, |
119 | 47.2k | [&](auto&& x) { |
120 | 47.2k | assert(a.count(x.first)); |
121 | 0 | assert(!b.count(x.first)); |
122 | 47.2k | }, |
123 | 15.3k | [&](auto&& x, auto&& y) { |
124 | 2.03k | assert(x.first == y.first); |
125 | 0 | assert(x.second != y.second); |
126 | 2.03k | }); |
127 | 15.3k | } |
128 | 28.7k | default: |
129 | 28.7k | break; |
130 | 202k | }; |
131 | 197k | return true; |
132 | 202k | }); |
133 | 86.4k | } |