blob: a136da213ab42e75eadf0219603ffcd09868371d [file] [log] [blame]
// Copyright 2020 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
// Simply forwards to <fuzzer/FuzzedDataProvider.h> when available from clang,
// or provides a simple stub implementation.
#pragma once
#if defined(__clang__)
#include <fuzzer/FuzzedDataProvider.h>
#else // !defined(__clang__)
// If a fuzzer wants to use FuzzedDataProvider to build a fuzz target unit
// test without clang, it can use this trivial class with the same signature.
// The behavior will NOT be the same as a fuzzer unit test built by clang for
// non-trivial inputs. This means non-clang fuzzer unit tests will not be
// effective regression tests if given a seed corpus. These non-clang tests are
// still useful, however, as they will guarantee the fuzzer code can compile and
// link.
//
// The methods of this class are intentionally undocumented. To see the
// documentation for each, consult the real header file, e.g. in
// .cipd/pigweed/lib/clang/11.0.0/include/fuzzer/FuzzedDataProvider.h
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
#include "pw_log/log.h"
class FuzzedDataProvider {
public:
FuzzedDataProvider(const uint8_t* data, size_t size) {
PW_UNUSED(data);
PW_UNUSED(size);
PW_LOG_INFO("Fuzzing is disabled for the current compiler.");
PW_LOG_INFO("Using trivial stub implementation for FuzzedDataProvider.");
}
~FuzzedDataProvider() = default;
template <typename T>
std::vector<T> ConsumeBytes(size_t num_bytes) {
PW_UNUSED(num_bytes);
return std::vector<T>{};
}
template <typename T>
std::vector<T> ConsumeBytesWithTerminator(size_t num_bytes,
T terminator = 0) {
PW_UNUSED(num_bytes);
return std::vector<T>{terminator};
}
template <typename T>
std::vector<T> ConsumeRemainingBytes() {
return std::vector<T>{};
}
std::string ConsumeBytesAsString(size_t num_bytes) {
PW_UNUSED(num_bytes);
return std::string{};
}
std::string ConsumeRandomLengthString(size_t max_length) {
PW_UNUSED(max_length);
return std::string{};
}
std::string ConsumeRandomLengthString() { return std::string{}; }
std::string ConsumeRemainingBytesAsString() { return std::string{}; }
template <typename T>
T ConsumeIntegral() {
return T(0);
}
template <typename T>
T ConsumeIntegralInRange(T min, T max) {
PW_UNUSED(max);
return T(min);
}
template <typename T>
T ConsumeFloatingPoint() {
return T(0.0);
}
template <typename T>
T ConsumeFloatingPointInRange(T min, T max) {
PW_UNUSED(max);
return T(min);
}
template <typename T>
T ConsumeProbability() {
return T(0.0);
}
bool ConsumeBool() { return false; }
template <typename T>
T ConsumeEnum() {
return static_cast<T>(0);
}
template <typename T, size_t size>
T PickValueInArray(const T (&array)[size]) {
static_assert(size > 0, "The array must be non empty.");
return array[0];
}
template <typename T>
T PickValueInArray(std::initializer_list<const T> list) {
static_assert(list.size() > 0, "The list must be non empty.");
return *list.begin();
}
size_t ConsumeData(void* destination, size_t num_bytes) {
PW_UNUSED(destination);
PW_UNUSED(num_bytes);
return 0;
}
size_t remaining_bytes() { return 0; }
};
#endif // defined(__clang__)