pw_fuzzer: Move `Domain` from fuzztest::internal to fuzztest
This CL moves the dummy definition of `Domain<T>` to match the real
location in FuzzTest. This allows fuzzer helpers to specify a return
type instead of using `auto`.
Change-Id: I49810c0f2fe40c97c5b9673c1c3413690331c008
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/178213
Reviewed-by: Taylor Cramer <cramertj@google.com>
Commit-Queue: Aaron Green <aarongreen@google.com>
diff --git a/pw_fuzzer/private_overrides/pw_fuzzer/internal/fuzztest.h b/pw_fuzzer/private_overrides/pw_fuzzer/internal/fuzztest.h
index 61066d5..de3b7f3 100644
--- a/pw_fuzzer/private_overrides/pw_fuzzer/internal/fuzztest.h
+++ b/pw_fuzzer/private_overrides/pw_fuzzer/internal/fuzztest.h
@@ -55,7 +55,6 @@
fuzztest::internal::TypeCheckFuzzTest(test_name).IgnoreFunction()
namespace fuzztest {
-namespace internal {
/// Stub for a FuzzTest domain that produces values.
///
@@ -71,6 +70,8 @@
using value_type = T;
};
+namespace internal {
+
/// Stub for a FuzzTest domain that produces containers of values.
///
/// This struct is an extension of `Domain` that add stubs for the methods that
@@ -149,7 +150,7 @@
template <typename T>
auto Arbitrary() {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
////////////////////////////////////////////////////////////////
@@ -159,20 +160,20 @@
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#oneof
template <int&... ExplicitArgumentBarrier, typename T, typename... Domains>
-auto OneOf(internal::Domain<T>, Domains...) {
- return internal::Domain<T>{};
+auto OneOf(Domain<T>, Domains...) {
+ return Domain<T>{};
}
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#oneof
template <typename T>
auto Just(T) {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#map
template <int&... ExplicitArgumentBarrier, typename Mapper, typename... Inner>
auto Map(Mapper, Inner...) {
- return internal::Domain<std::decay_t<
+ return Domain<std::decay_t<
std::invoke_result_t<Mapper, typename Inner::value_type&...>>>{};
}
@@ -184,14 +185,14 @@
typename FlatMapper,
typename... Inner>
auto FlatMap(FlatMapper, Inner...) {
- return internal::Domain<
+ return Domain<
typename FlatMapOutputDomain<FlatMapper, Inner...>::value_type>{};
}
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#filter
template <int&... ExplicitArgumentBarrier, typename T, typename Pred>
-auto Filter(Pred, internal::Domain<T>) {
- return internal::Domain<T>{};
+auto Filter(Pred, Domain<T>) {
+ return Domain<T>{};
}
////////////////////////////////////////////////////////////////
@@ -271,7 +272,7 @@
// TODO: b/285775246 - Add support for `fuzztest::InRegexp`.
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#inregexp-domains
// inline auto InRegexp(std::string_view) {
-// return internal::Domain<std::string_view>{};
+// return Domain<std::string_view>{};
// }
////////////////////////////////////////////////////////////////
@@ -280,12 +281,12 @@
template <typename T>
auto ElementOf(std::initializer_list<T>) {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
template <typename T>
auto BitFlagCombinationOf(std::initializer_list<T>) {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
////////////////////////////////////////////////////////////////
@@ -293,19 +294,19 @@
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#container-combinators
template <typename T, int&... ExplicitArgumentBarrier, typename U>
-auto ContainerOf(internal::Domain<U>) {
+auto ContainerOf(Domain<U>) {
return internal::ContainerDomain<T>{};
}
template <template <typename, typename...> class T,
int&... ExplicitArgumentBarrier,
typename U>
-auto ContainerOf(internal::Domain<U>) {
+auto ContainerOf(Domain<U>) {
return internal::ContainerDomain<T<U>>{};
}
template <typename T, int&... ExplicitArgumentBarrier, typename U>
-auto UniqueElementsContainerOf(internal::Domain<U>) {
+auto UniqueElementsContainerOf(Domain<U>) {
return internal::ContainerDomain<T>{};
}
@@ -319,62 +320,62 @@
// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#container-combinators
template <int&... ExplicitArgumentBarrier, typename T, typename... Domains>
-auto ArrayOf(internal::Domain<T>, Domains... others) {
- return internal::Domain<std::array<T, 1 + sizeof...(others)>>{};
+auto ArrayOf(Domain<T>, Domains... others) {
+ return Domain<std::array<T, 1 + sizeof...(others)>>{};
}
template <int N, int&... ExplicitArgumentBarrier, typename T>
-auto ArrayOf(const internal::Domain<T>&) {
- return internal::Domain<std::array<T, N>>{};
+auto ArrayOf(const Domain<T>&) {
+ return Domain<std::array<T, N>>{};
}
template <typename T, int&... ExplicitArgumentBarrier, typename... Inner>
auto StructOf(Inner...) {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
template <typename T, int&... ExplicitArgumentBarrier>
auto ConstructorOf() {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
template <typename T,
int&... ExplicitArgumentBarrier,
typename U,
typename... Inner>
-auto ConstructorOf(internal::Domain<U>, Inner... inner) {
+auto ConstructorOf(Domain<U>, Inner... inner) {
return ConstructorOf<T>(inner...);
}
template <int&... ExplicitArgumentBarrier, typename T1, typename T2>
-auto PairOf(internal::Domain<T1>, internal::Domain<T2>) {
- return internal::Domain<std::pair<T1, T2>>{};
+auto PairOf(Domain<T1>, Domain<T2>) {
+ return Domain<std::pair<T1, T2>>{};
}
template <int&... ExplicitArgumentBarrier, typename... Inner>
auto TupleOf(Inner...) {
- return internal::Domain<std::tuple<typename Inner::value_type...>>{};
+ return Domain<std::tuple<typename Inner::value_type...>>{};
}
template <typename T, int&... ExplicitArgumentBarrier, typename... Inner>
auto VariantOf(Inner...) {
- return internal::Domain<T>{};
+ return Domain<T>{};
}
template <int&... ExplicitArgumentBarrier, typename... Inner>
auto VariantOf(Inner...) {
- return internal::Domain<std::variant<typename Inner::value_type...>>{};
+ return Domain<std::variant<typename Inner::value_type...>>{};
}
template <template <typename> class Optional,
int&... ExplicitArgumentBarrier,
typename T>
-auto OptionalOf(internal::Domain<T>) {
+auto OptionalOf(Domain<T>) {
return internal::OptionalDomain<Optional<T>>{};
}
template <int&... ExplicitArgumentBarrier, typename T>
-auto OptionalOf(internal::Domain<T> inner) {
+auto OptionalOf(Domain<T> inner) {
return OptionalOf<std::optional>(inner);
}
diff --git a/pw_fuzzer/public/pw_fuzzer/fuzztest.h b/pw_fuzzer/public/pw_fuzzer/fuzztest.h
index 4ca52c9..9e72ec2 100644
--- a/pw_fuzzer/public/pw_fuzzer/fuzztest.h
+++ b/pw_fuzzer/public/pw_fuzzer/fuzztest.h
@@ -49,6 +49,9 @@
namespace pw::fuzzer {
+template <typename T>
+using Domain = fuzztest::Domain<T>;
+
////////////////////////////////////////////////////////////////
// Arbitrary domains
// Additional specializations are provided with the Pigweed domains.
