/src/immer/extra/fuzzer/map-st-str-conflict.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/map.hpp> |
13 | | |
14 | | #include <immer/algorithm.hpp> |
15 | | |
16 | | #include <array> |
17 | | |
18 | | using st_memory = immer::memory_policy<immer::heap_policy<immer::cpp_heap>, |
19 | | immer::unsafe_refcount_policy, |
20 | | immer::no_lock_policy, |
21 | | immer::no_transience_policy, |
22 | | false>; |
23 | | |
24 | | struct colliding_hash_t |
25 | | { |
26 | | std::size_t operator()(const std::string& x) const |
27 | 13.2M | { |
28 | 13.2M | return std::hash<std::string>{}(x) & ~((std::size_t{1} << 48) - 1); |
29 | 13.2M | } |
30 | | }; |
31 | | |
32 | | extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, |
33 | | std::size_t size) |
34 | 3.66k | { |
35 | 3.66k | constexpr auto var_count = 4; |
36 | | |
37 | 3.66k | using map_t = immer::map<std::string, |
38 | 3.66k | immer::box<std::string>, |
39 | 3.66k | colliding_hash_t, |
40 | 3.66k | std::equal_to<>, |
41 | 3.66k | st_memory, |
42 | 3.66k | 3>; |
43 | | |
44 | 3.66k | auto vars = std::array<map_t, var_count>{}; |
45 | | |
46 | 1.43M | auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; |
47 | | |
48 | 384k | return fuzzer_input{data, size}.run([&](auto& in) { |
49 | 384k | enum ops |
50 | 384k | { |
51 | 384k | op_set, |
52 | 384k | op_erase, |
53 | 384k | op_set_move, |
54 | 384k | op_erase_move, |
55 | 384k | op_iterate, |
56 | 384k | op_find, |
57 | 384k | op_update, |
58 | 384k | op_update_move, |
59 | 384k | op_diff |
60 | 384k | }; |
61 | 384k | auto src = read<char>(in, is_valid_var); |
62 | 384k | auto dst = read<char>(in, is_valid_var); |
63 | 384k | assert(vars[src].impl().check_champ()); |
64 | 380k | switch (read<char>(in)) { |
65 | 23.7k | case op_set: { |
66 | 23.7k | auto value = std::to_string(read<size_t>(in)); |
67 | 23.7k | vars[dst] = vars[src].set(value, "foo"); |
68 | 23.7k | break; |
69 | 0 | } |
70 | 15.8k | case op_erase: { |
71 | 15.8k | auto value = std::to_string(read<size_t>(in)); |
72 | 15.8k | vars[dst] = vars[src].erase(value); |
73 | 15.8k | break; |
74 | 0 | } |
75 | 15.0k | case op_set_move: { |
76 | 15.0k | auto value = std::to_string(read<size_t>(in)); |
77 | 15.0k | vars[dst] = std::move(vars[src]).set(value, "foo"); |
78 | 15.0k | break; |
79 | 0 | } |
80 | 9.68k | case op_erase_move: { |
81 | 9.68k | auto value = std::to_string(read<size_t>(in)); |
82 | 9.68k | vars[dst] = std::move(vars[src]).erase(value); |
83 | 9.68k | break; |
84 | 0 | } |
85 | 11.5k | case op_iterate: { |
86 | 11.5k | auto srcv = vars[src]; |
87 | 156k | for (const auto& v : srcv) { |
88 | 156k | vars[dst] = vars[dst].set(v.first, v.second); |
89 | 156k | } |
90 | 11.5k | break; |
91 | 0 | } |
92 | 5.36k | case op_find: { |
93 | 5.36k | auto value = std::to_string(read<size_t>(in)); |
94 | 5.36k | auto res = vars[src].find(value); |
95 | 5.36k | if (res != nullptr) { |
96 | 3.69k | vars[dst] = vars[dst].set(*res, "foo"); |
97 | 3.69k | } |
98 | 5.36k | break; |
99 | 0 | } |
100 | 126k | case op_update: { |
101 | 126k | auto key = std::to_string(read<size_t>(in)); |
102 | 126k | vars[dst] = vars[src].update( |
103 | 126k | key, [](std::string x) { return std::move(x) + "bar"; }); |
104 | 126k | break; |
105 | 0 | } |
106 | 137k | case op_update_move: { |
107 | 137k | auto key = std::to_string(read<size_t>(in)); |
108 | 137k | vars[dst] = std::move(vars[src]).update( |
109 | 137k | key, [](std::string x) { return std::move(x) + "baz"; }); |
110 | 137k | break; |
111 | 0 | } |
112 | 22.0k | case op_diff: { |
113 | 22.0k | auto&& a = vars[src]; |
114 | 22.0k | auto&& b = vars[dst]; |
115 | 22.0k | diff( |
116 | 22.0k | a, |
117 | 22.0k | b, |
118 | 125k | [&](auto&& x) { |
119 | 125k | assert(!a.count(x.first)); |
120 | 125k | assert(b.count(x.first)); |
121 | 125k | }, |
122 | 140k | [&](auto&& x) { |
123 | 140k | assert(a.count(x.first)); |
124 | 140k | assert(!b.count(x.first)); |
125 | 140k | }, |
126 | 54.0k | [&](auto&& x, auto&& y) { |
127 | 54.0k | assert(x.first == y.first); |
128 | 54.0k | assert(x.second != y.second); |
129 | 54.0k | }); |
130 | 22.0k | } |
131 | 35.4k | default: |
132 | 35.4k | break; |
133 | 380k | }; |
134 | 380k | return true; |
135 | 380k | }); |
136 | 3.66k | } |