Add flatbuffers domain

PiperOrigin-RevId: 732932597

Author: FuzzTest Team

.github/workflows/cmake_test.yml

@@ -77,6 +77,7 @@ jobs:
             -D CMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -D CMAKE_BUILD_TYPE=RelWithDebug \
             -D FUZZTEST_BUILD_TESTING=on \
+            -D FUZZTEST_BUILD_FLATBUFFERS=on \
           && cmake --build build -j $(nproc) \
           && ctest --test-dir build -j $(nproc) --output-on-failure
       - name: Run all tests in default mode with gcc
@@ -90,6 +91,7 @@ jobs:
             -D CMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -D CMAKE_BUILD_TYPE=RelWithDebug \
             -D FUZZTEST_BUILD_TESTING=on \
+            -D FUZZTEST_BUILD_FLATBUFFERS=on \
           && cmake --build build_gcc -j $(nproc) \
           && ctest --test-dir build_gcc -j $(nproc) --output-on-failure
       - name: Run end-to-end tests in fuzzing mode
@@ -104,6 +106,7 @@ jobs:
             -D CMAKE_BUILD_TYPE=RelWithDebug \
             -D FUZZTEST_FUZZING_MODE=on \
             -D FUZZTEST_BUILD_TESTING=on \
+            -D FUZZTEST_BUILD_FLATBUFFERS=on \
           && cmake --build build -j $(nproc) \
           && ctest --test-dir build -j $(nproc) --output-on-failure -R "functional_test"
       - name: Save new cache based on main

CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.19)
 project(fuzztest)
 
 option(FUZZTEST_BUILD_TESTING "Building the tests." OFF)
+option(FUZZTEST_BUILD_FLATBUFFERS "Building the flatbuffers support." OFF)
 option(FUZZTEST_FUZZING_MODE "Building the fuzztest in fuzzing mode." OFF)
 set(FUZZTEST_COMPATIBILITY_MODE "" CACHE STRING "Compatibility mode. Available options: <empty>, libfuzzer")
 set(CMAKE_CXX_STANDARD 17)

MODULE.bazel

@@ -42,6 +42,10 @@ bazel_dep(
     name = "platforms",
     version = "0.0.10",
 )
+bazel_dep(
+    name = "flatbuffers",
+    version = "25.2.10"
+)
 # GoogleTest is not a dev dependency, because it's needed when FuzzTest is used
 # with GoogleTest integration (e.g., googletest_adaptor). Note that the FuzzTest
 # framework can be used without GoogleTest integration as well.
@@ -55,8 +59,6 @@ bazel_dep(
     name = "protobuf",
     version = "30.2",
 )
-# TODO(lszekeres): Make this a dev dependency, as the protobuf library is only
-# required for testing.
 bazel_dep(
     name = "rules_proto",
     version = "7.1.0",

cmake/BuildDependencies.cmake

@@ -21,6 +21,9 @@ set(proto_TAG v30.2)
 set(nlohmann_json_URL https://github.com/nlohmann/json.git)
 set(nlohmann_json_TAG v3.11.3)
 
+set(flatbuffers_URL https://github.com/google/flatbuffers.git)
+set(flatbuffers_TAG v25.2.10)
+
 if(POLICY CMP0135)
 	cmake_policy(SET CMP0135 NEW)
 	set(CMAKE_POLICY_DEFAULT_CMP0135 NEW)
@@ -50,6 +53,14 @@ FetchContent_Declare(
   URL_HASH MD5=${antlr_cpp_MD5}
 )
 
+if (FUZZTEST_BUILD_FLATBUFFERS)
+  FetchContent_Declare(
+    flatbuffers
+    GIT_REPOSITORY ${flatbuffers_URL}
+    GIT_TAG        ${flatbuffers_TAG}
+  )
+endif()
+
 if (FUZZTEST_BUILD_TESTING)
 
   FetchContent_Declare(
@@ -87,3 +98,9 @@ if (FUZZTEST_BUILD_TESTING)
   FetchContent_MakeAvailable(nlohmann_json)
 
 endif ()
+
+if (FUZZTEST_BUILD_FLATBUFFERS)
+  set(FLATBUFFERS_BUILD_TESTS OFF)
+  set(FLATBUFFERS_BUILD_INSTALL OFF)
+  FetchContent_MakeAvailable(flatbuffers)
+endif()

cmake/generate_cmake_from_bazel.py

@@ -52,6 +52,7 @@
     "@abseil-cpp//absl/types:optional": "absl::optional",
     "@abseil-cpp//absl/types:span": "absl::span",
     "@abseil-cpp//absl/types:variant": "absl::variant",
+    "@flatbuffers//:runtime_cc": "flatbuffers",
     "@googletest//:gtest": "GTest::gtest",
     "@googletest//:gtest_main": "GTest::gmock_main",
     "@protobuf//:protobuf": "protobuf::libprotobuf",

domain_tests/BUILD

@@ -25,10 +25,29 @@ cc_test(
         ":domain_testing",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/random",
+        "@abseil-cpp//absl/random:bit_gen_ref",
+        "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/types:optional",
         "@abseil-cpp//absl/types:span",
         "@abseil-cpp//absl/types:variant",
         "@com_google_fuzztest//fuzztest:domain_core",
+        "@com_google_fuzztest//fuzztest:type_support",
+        "@googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "arbitrary_domains_flatbuffers_test",
+    srcs = ["arbitrary_domains_flatbuffers_test.cc"],
+    deps = [
+        ":domain_testing",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/random",
+        "@com_google_fuzztest//fuzztest:domain",
+        "@com_google_fuzztest//fuzztest:flatbuffers",
+        "@com_google_fuzztest//fuzztest:meta",
+        "@com_google_fuzztest//fuzztest:test_flatbuffers_cc_fbs",
+        "@flatbuffers//:runtime_cc",
         "@googletest//:gtest_main",
     ],
 )

domain_tests/CMakeLists.txt

@@ -11,14 +11,40 @@ fuzztest_cc_test(
   DEPS
     fuzztest::domain_testing
     absl::flat_hash_set
+    absl::random_bit_gen_ref
     absl::random_random
     absl::optional
     absl::span
+    absl::status
     absl::variant
     fuzztest::domain_core
+    fuzztest::type_support
     GTest::gmock_main
 )
 
+if (FUZZTEST_BUILD_FLATBUFFERS)
+  fuzztest_cc_test(
+    NAME
+      arbitrary_domains_flatbuffers_test
+    SRCS
+      "arbitrary_domains_flatbuffers_test.cc"
+    DEPS
+      absl::flat_hash_set
+      absl::random_bit_gen_ref
+      absl::random_random
+      absl::strings
+      flatbuffers
+      fuzztest::domain
+      fuzztest::domain_testing
+      fuzztest::flatbuffers
+      GTest::gmock_main
+      test_flatbuffers
+  )
+  add_dependencies(fuzztest_arbitrary_domains_flatbuffers_test
+    GENERATE_test_flatbuffers
+  )
+endif()
+
 fuzztest_cc_test(
   NAME
     arbitrary_domains_protobuf_test

domain_tests/aggregate_combinators_test.cc

@@ -17,19 +17,23 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <variant>
 #include <vector>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/container/flat_hash_set.h"
+#include "absl/random/bit_gen_ref.h"
 #include "absl/random/random.h"
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 #include "absl/types/variant.h"
 #include "./fuzztest/domain_core.h"
 #include "./domain_tests/domain_testing.h"
+#include "./fuzztest/internal/type_support.h"
 
 namespace fuzztest {
 namespace {
@@ -446,5 +450,97 @@ TEST(TupleOf, ValidationRejectsInvalidInnerValue) {
           R"(Invalid value in aggregate >> The value .+ is not InRange\(.+\))")));
 }
 
+TEST(TupleOf, DomainWithPairCorpusType) {
+  class DomainWithPairCorpusType
+      : public fuzztest::domain_implementor::DomainBase<
+            DomainWithPairCorpusType, std::pair<int, int>> {
+   public:
+    using corpus_type = DomainWithPairCorpusType::DomainBase::corpus_type;
+    using value_type = DomainWithPairCorpusType::DomainBase::value_type;
+
+    corpus_type Init(absl::BitGenRef prng) { return std::make_pair(0, 0); }
+
+    void Mutate(corpus_type& val, absl::BitGenRef prng,
+                const domain_implementor::MutationMetadata& metadata,
+                bool only_shrink) {}
+
+    absl::Status ValidateCorpusValue(const corpus_type& value) const {
+      return absl::OkStatus();
+    }
+
+    auto GetPrinter() const { return internal::UnknownPrinter(); }
+  };
+
+  {
+    auto domain = TupleOf(DomainWithPairCorpusType{});
+    auto value = std::make_tuple(std::make_pair(1, 2));
+    auto optional_corpus_tuple = domain.FromValue(value);
+    EXPECT_TRUE(optional_corpus_tuple.has_value());
+    if (optional_corpus_tuple.has_value()) {
+      EXPECT_EQ(std::get<0>(optional_corpus_tuple.value()),
+                std::make_pair(1, 2));
+    }
+  }
+  {
+    auto domain =
+        TupleOf(DomainWithPairCorpusType{}, DomainWithPairCorpusType{});
+    auto value = std::make_tuple(std::make_pair(1, 2), std::make_pair(3, 4));
+    auto optional_corpus_tuple = domain.FromValue(value);
+    EXPECT_TRUE(optional_corpus_tuple.has_value());
+    if (optional_corpus_tuple.has_value()) {
+      EXPECT_EQ(std::get<0>(optional_corpus_tuple.value()),
+                std::make_pair(1, 2));
+      EXPECT_EQ(std::get<1>(optional_corpus_tuple.value()),
+                std::make_pair(3, 4));
+    }
+  }
+}
+
+TEST(TupleOf, DomainWithTupleCorpusType) {
+  class DomainWithTupleCorpusType
+      : public fuzztest::domain_implementor::DomainBase<
+            DomainWithTupleCorpusType, std::tuple<int, int>> {
+   public:
+    using corpus_type = DomainWithTupleCorpusType::DomainBase::corpus_type;
+    using value_type = DomainWithTupleCorpusType::DomainBase::value_type;
+
+    corpus_type Init(absl::BitGenRef prng) { return std::make_tuple(0, 0); }
+
+    void Mutate(corpus_type& val, absl::BitGenRef prng,
+                const domain_implementor::MutationMetadata& metadata,
+                bool only_shrink) {}
+
+    absl::Status ValidateCorpusValue(const corpus_type& value) const {
+      return absl::OkStatus();
+    }
+
+    auto GetPrinter() const { return internal::UnknownPrinter(); }
+  };
+
+  {
+    auto domain = TupleOf(DomainWithTupleCorpusType{});
+    auto value = std::make_tuple(std::make_pair(1, 2));
+    auto optional_corpus_tuple = domain.FromValue(value);
+    EXPECT_TRUE(optional_corpus_tuple.has_value());
+    if (optional_corpus_tuple.has_value()) {
+      EXPECT_EQ(std::get<0>(optional_corpus_tuple.value()),
+                std::make_tuple(1, 2));
+    }
+  }
+  {
+    auto domain =
+        TupleOf(DomainWithTupleCorpusType{}, DomainWithTupleCorpusType{});
+    auto value = std::make_tuple(std::make_tuple(1, 2), std::make_tuple(3, 4));
+    auto optional_corpus_tuple = domain.FromValue(value);
+    EXPECT_TRUE(optional_corpus_tuple.has_value());
+    if (optional_corpus_tuple.has_value()) {
+      EXPECT_EQ(std::get<0>(optional_corpus_tuple.value()),
+                std::make_tuple(1, 2));
+      EXPECT_EQ(std::get<1>(optional_corpus_tuple.value()),
+                std::make_tuple(3, 4));
+    }
+  }
+}
+
 }  // namespace
 }  // namespace fuzztest