/root/bitcoin/src/test/fuzz/poolresource.cpp

Source
// Copyright (c) 2022-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <random.h>
#include <span.h>
#include <support/allocators/pool.h>
#include <test/fuzz/FuzzedDataProvider.h>
#include <test/fuzz/fuzz.h>
#include <test/fuzz/util.h>
#include <test/util/poolresourcetester.h>
#include <util/byte_units.h>

#include <cstdint>
#include <tuple>
#include <vector>

namespace {

template <std::size_t MAX_BLOCK_SIZE_BYTES, std::size_t ALIGN_BYTES>
class PoolResourceFuzzer
{
    FuzzedDataProvider& m_provider;
    PoolResource<MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES> m_test_resource;
    uint64_t m_sequence{0};
    size_t m_total_allocated{};

    struct Entry {
        std::span<std::byte> span;
        size_t alignment;
        uint64_t seed;

        Entry(std::span<std::byte> s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {}
    };

    std::vector<Entry> m_entries;

public:
    PoolResourceFuzzer(FuzzedDataProvider& provider)
        : m_provider{provider},
          m_test_resource{provider.ConsumeIntegralInRange<size_t>(MAX_BLOCK_SIZE_BYTES, 262144)}
    {
    }

    void Allocate(size_t size, size_t alignment)
    {
        assert(size > 0);                           // Must allocate at least 1 byte.
        assert(alignment > 0);                      // Alignment must be at least 1.
        assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2.
        assert((size & (alignment - 1)) == 0);      // Size must be a multiple of alignment.

        auto span = std::span(static_cast<std::byte*>(m_test_resource.Allocate(size, alignment)), size);
        m_total_allocated += size;

        auto ptr_val = reinterpret_cast<std::uintptr_t>(span.data());
        assert((ptr_val & (alignment - 1)) == 0);

        uint64_t seed = m_sequence++;
        RandomContentFill(m_entries.emplace_back(span, alignment, seed));
    }

    void
    Allocate()
    {
        if (m_total_allocated > 16_MiB) return;
        size_t alignment_bits = m_provider.ConsumeIntegralInRange<size_t>(0, 7);
        size_t alignment = size_t{1} << alignment_bits;
        size_t size_bits = m_provider.ConsumeIntegralInRange<size_t>(0, 16 - alignment_bits);
        size_t size = m_provider.ConsumeIntegralInRange<size_t>(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits;
        Allocate(size, alignment);
    }

    void RandomContentFill(Entry& entry)
    {
        InsecureRandomContext(entry.seed).fillrand(entry.span);
    }

    void RandomContentCheck(const Entry& entry)
    {
        std::vector<std::byte> expect(entry.span.size());
        InsecureRandomContext(entry.seed).fillrand(expect);
        assert(std::ranges::equal(entry.span, expect));
    }

    void Deallocate(const Entry& entry)
    {
        auto ptr_val = reinterpret_cast<std::uintptr_t>(entry.span.data());
        assert((ptr_val & (entry.alignment - 1)) == 0);
        RandomContentCheck(entry);
        m_total_allocated -= entry.span.size();
        m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment);
    }

    void Deallocate()
    {
        if (m_entries.empty()) {
            return;
        }

        size_t idx = m_provider.ConsumeIntegralInRange<size_t>(0, m_entries.size() - 1);
        Deallocate(m_entries[idx]);
        if (idx != m_entries.size() - 1) {
            m_entries[idx] = std::move(m_entries.back());
        }
        m_entries.pop_back();
    }

    void Clear()
    {
        while (!m_entries.empty()) {
            Deallocate();
        }

        PoolResourceTester::CheckAllDataAccountedFor(m_test_resource);
    }

    void Fuzz()
    {
        LIMITED_WHILE (m_provider.ConsumeBool(), 10000) {
            CallOneOf(
                m_provider,
                [&] { Allocate(); },
                [&] { Deallocate(); });
        }
        Clear();
    }
};


} // namespace

FUZZ_TARGET(pool_resource)
{
    FuzzedDataProvider provider(buffer.data(), buffer.size());
    CallOneOf(
        provider,
        [&] { PoolResourceFuzzer<128, 1>{provider}.Fuzz(); },
        [&] { PoolResourceFuzzer<128, 2>{provider}.Fuzz(); },
        [&] { PoolResourceFuzzer<128, 4>{provider}.Fuzz(); },
        [&] { PoolResourceFuzzer<128, 8>{provider}.Fuzz(); },

        [&] { PoolResourceFuzzer<8, 8>{provider}.Fuzz(); },
        [&] { PoolResourceFuzzer<16, 16>{provider}.Fuzz(); },

        [&] { PoolResourceFuzzer<256, alignof(max_align_t)>{provider}.Fuzz(); },
        [&] { PoolResourceFuzzer<256, 64>{provider}.Fuzz(); });
}

Line	Count	Source
1		// Copyright (c) 2022-present The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5		#include <random.h>
6		#include <span.h>
7		#include <support/allocators/pool.h>
8		#include <test/fuzz/FuzzedDataProvider.h>
9		#include <test/fuzz/fuzz.h>
10		#include <test/fuzz/util.h>
11		#include <test/util/poolresourcetester.h>
12		#include <util/byte_units.h>
13
14		#include <cstdint>
15		#include <tuple>
16		#include <vector>
17
18		namespace {
19
20		template <std::size_t MAX_BLOCK_SIZE_BYTES, std::size_t ALIGN_BYTES>
21		class PoolResourceFuzzer
22		{
23		FuzzedDataProvider& m_provider;
24		PoolResource<MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES> m_test_resource;
25		uint64_t m_sequence{0};
26		size_t m_total_allocated{};
27
28		struct Entry {
29		std::span<std::byte> span;
30		size_t alignment;
31		uint64_t seed;
32
33	0	Entry(std::span<std::byte> s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE5EntryC2ESt4spanISt4byteLm18446744073709551615EEmm
34		};
35
36		std::vector<Entry> m_entries;
37
38		public:
39		PoolResourceFuzzer(FuzzedDataProvider& provider)
40	0	: m_provider{provider},
41	0	m_test_resource{provider.ConsumeIntegralInRange<size_t>(MAX_BLOCK_SIZE_BYTES, 262144)}
42	0	{
43	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EEC2ER18FuzzedDataProvider Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EEC2ER18FuzzedDataProvider
44
45		void Allocate(size_t size, size_t alignment)
46	0	{
47	0	assert(size > 0); // Must allocate at least 1 byte. Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0] Branch (47:9): [True: 0, False: 0]
48	0	assert(alignment > 0); // Alignment must be at least 1. Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0] Branch (48:9): [True: 0, False: 0]
49	0	assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0] Branch (49:9): [True: 0, False: 0]
50	0	assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0] Branch (50:9): [True: 0, False: 0]
51
52	0	auto span = std::span(static_cast<std::byte*>(m_test_resource.Allocate(size, alignment)), size);
53	0	m_total_allocated += size;
54
55	0	auto ptr_val = reinterpret_cast<std::uintptr_t>(span.data());
56	0	assert((ptr_val & (alignment - 1)) == 0); Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0] Branch (56:9): [True: 0, False: 0]
57
58	0	uint64_t seed = m_sequence++;
59	0	RandomContentFill(m_entries.emplace_back(span, alignment, seed));
60	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE8AllocateEmm Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE8AllocateEmm
61
62		void
63		Allocate()
64	0	{
65	0	if (m_total_allocated > 16_MiB) return; Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0] Branch (65:13): [True: 0, False: 0]
66	0	size_t alignment_bits = m_provider.ConsumeIntegralInRange<size_t>(0, 7);
67	0	size_t alignment = size_t{1} << alignment_bits;
68	0	size_t size_bits = m_provider.ConsumeIntegralInRange<size_t>(0, 16 - alignment_bits);
69	0	size_t size = m_provider.ConsumeIntegralInRange<size_t>(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits;
70	0	Allocate(size, alignment);
71	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE8AllocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE8AllocateEv
72
73		void RandomContentFill(Entry& entry)
74	0	{
75	0	InsecureRandomContext(entry.seed).fillrand(entry.span);
76	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE17RandomContentFillERNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE17RandomContentFillERNS1_5EntryE
77
78		void RandomContentCheck(const Entry& entry)
79	0	{
80	0	std::vector<std::byte> expect(entry.span.size());
81	0	InsecureRandomContext(entry.seed).fillrand(expect);
82	0	assert(std::ranges::equal(entry.span, expect)); Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0] Branch (82:9): [True: 0, False: 0]
83	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE18RandomContentCheckERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE18RandomContentCheckERKNS1_5EntryE
84
85		void Deallocate(const Entry& entry)
86	0	{
87	0	auto ptr_val = reinterpret_cast<std::uintptr_t>(entry.span.data());
88	0	assert((ptr_val & (entry.alignment - 1)) == 0); Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0] Branch (88:9): [True: 0, False: 0]
89	0	RandomContentCheck(entry);
90	0	m_total_allocated -= entry.span.size();
91	0	m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment);
92	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE10DeallocateERKNS1_5EntryE Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE10DeallocateERKNS1_5EntryE
93
94		void Deallocate()
95	0	{
96	0	if (m_entries.empty()) { Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0] Branch (96:13): [True: 0, False: 0]
97	0	return;
98	0	}
99
100	0	size_t idx = m_provider.ConsumeIntegralInRange<size_t>(0, m_entries.size() - 1);
101	0	Deallocate(m_entries[idx]);
102	0	if (idx != m_entries.size() - 1) { Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0] Branch (102:13): [True: 0, False: 0]
103	0	m_entries[idx] = std::move(m_entries.back());
104	0	}
105	0	m_entries.pop_back();
106	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE10DeallocateEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE10DeallocateEv
107
108		void Clear()
109	0	{
110	0	while (!m_entries.empty()) { Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0] Branch (110:16): [True: 0, False: 0]
111	0	Deallocate();
112	0	}
113
114	0	PoolResourceTester::CheckAllDataAccountedFor(m_test_resource);
115	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE5ClearEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE5ClearEv
116
117		void Fuzz()
118	0	{
119	0	LIMITED_WHILE (m_provider.ConsumeBool(), 10000) {
120	0	CallOneOf(
121	0	m_provider,
122	0	[&] { Allocate(); }, Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEvENKUlvE_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEvENKUlvE_clEv
123	0	[&] { Deallocate(); }); Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEvENKUlvE0_clEv Unexecuted instantiation: poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEvENKUlvE0_clEv
124	0	}
125	0	Clear();
126	0	} Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEv Unexecuted instantiation: poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEv
127		};
128
129
130		} // namespace
131
132		FUZZ_TARGET(pool_resource)
133	0	{
134	0	FuzzedDataProvider provider(buffer.data(), buffer.size());
135	0	CallOneOf(
136	0	provider,
137	0	[&] { PoolResourceFuzzer<128, 1>{provider}.Fuzz(); },
138	0	[&] { PoolResourceFuzzer<128, 2>{provider}.Fuzz(); },
139	0	[&] { PoolResourceFuzzer<128, 4>{provider}.Fuzz(); },
140	0	[&] { PoolResourceFuzzer<128, 8>{provider}.Fuzz(); },
141
142	0	[&] { PoolResourceFuzzer<8, 8>{provider}.Fuzz(); },
143	0	[&] { PoolResourceFuzzer<16, 16>{provider}.Fuzz(); },
144
145	0	[&] { PoolResourceFuzzer<256, alignof(max_align_t)>{provider}.Fuzz(); },
146	0	[&] { PoolResourceFuzzer<256, 64>{provider}.Fuzz(); });
147	0	}

Coverage Report

Created: 2026-07-30 14:31