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

@@ -33,6 +33,21 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "arbitrary_domains_flatbuffers_test",
+    srcs = ["arbitrary_domains_flatbuffers_test.cc"],
+    deps = [
+        ":domain_testing",
+        "@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",
+    ],
+)
+
 cc_test(
     name = "arbitrary_domains_protobuf_test",
     srcs = ["arbitrary_domains_protobuf_test.cc"],

domain_tests/CMakeLists.txt

@@ -19,6 +19,28 @@ fuzztest_cc_test(
     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_random
+      absl::random_bit_gen_ref
+      absl::strings
+      flatbuffers
+      fuzztest::domain
+      fuzztest::domain_testing
+      test_flatbuffers
+      GTest::gmock_main
+  )
+  add_dependencies(fuzztest_arbitrary_domains_flatbuffers_test
+    GENERATE_test_flatbuffers
+  )
+endif()
+
 fuzztest_cc_test(
   NAME
     arbitrary_domains_protobuf_test

domain_tests/arbitrary_domains_flatbuffers_test.cc

@@ -0,0 +1,178 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//      http://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.
+
+#include <optional>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/random/random.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/flatbuffer_builder.h"
+#include "flatbuffers/string.h"
+#include "./fuzztest/domain.h"
+#include "./domain_tests/domain_testing.h"
+#include "./fuzztest/flatbuffers.h"
+#include "./fuzztest/internal/meta.h"
+#include "./fuzztest/internal/test_flatbuffers_generated.h"
+
+namespace fuzztest {
+namespace {
+
+using ::fuzztest::internal::OptionalRequiredTestFbsTable;
+using ::fuzztest::internal::SimpleTestFbsTable;
+using ::testing::Contains;
+using ::testing::IsTrue;
+using ::testing::ResultOf;
+
+TEST(FlatbuffersMetaTest, IsFlatbuffersTable) {
+  static_assert(internal::is_flatbuffers_table_v<SimpleTestFbsTable>);
+  static_assert(!internal::is_flatbuffers_table_v<int>);
+  static_assert(!internal::is_flatbuffers_table_v<std::optional<bool>>);
+}
+
+TEST(FlatbuffersTableImplTest, SimpleTestFbsTableValueRoundTrip) {
+  auto domain = Arbitrary<SimpleTestFbsTable>();
+
+  flatbuffers::FlatBufferBuilder fbb;
+  auto table_offset = internal::CreateSimpleTestFbsTableDirect(
+      fbb, true, 1.0, "foo bar baz", internal::TestFbsEnum_Second);
+  fbb.Finish(table_offset);
+  auto table = flatbuffers::GetRoot<SimpleTestFbsTable>(fbb.GetBufferPointer());
+
+  auto corpus = domain.FromValue(table);
+  ASSERT_TRUE(corpus.has_value());
+  ASSERT_OK(domain.ValidateCorpusValue(*corpus));
+
+  auto ir = domain.SerializeCorpus(corpus.value());
+
+  auto new_corpus = domain.ParseCorpus(ir);
+  ASSERT_TRUE(new_corpus.has_value());
+  ASSERT_OK(domain.ValidateCorpusValue(*new_corpus));
+
+  auto new_table = domain.GetValue(*new_corpus);
+  EXPECT_EQ(new_table->b(), true);
+  EXPECT_EQ(new_table->f(), 1.0);
+  EXPECT_EQ(new_table->str()->str(), "foo bar baz");
+  EXPECT_TRUE(new_table->e() == internal::TestFbsEnum_Second);
+}
+
+TEST(FlatbuffersTableImplTest, InitGeneratesSeeds) {
+  auto domain = Arbitrary<SimpleTestFbsTable>();
+
+  flatbuffers::FlatBufferBuilder fbb;
+  auto table_offset = internal::CreateSimpleTestFbsTableDirect(
+      fbb, true, 1.0, "foo bar baz", internal::TestFbsEnum_Second);
+  fbb.Finish(table_offset);
+  auto table = flatbuffers::GetRoot<SimpleTestFbsTable>(fbb.GetBufferPointer());
+
+  domain.WithSeeds({table});
+
+  std::vector<Value<decltype(domain)>> values;
+  absl::BitGen bitgen;
+  values.reserve(1000);
+  for (int i = 0; i < 1000; ++i) {
+    Value value(domain, bitgen);
+    values.push_back(std::move(value));
+  }
+
+  EXPECT_THAT(
+      values,
+      Contains(ResultOf(
+          [table](const auto& val) {
+            bool has_same_str =
+                val.user_value->str() == nullptr && table->str() == nullptr;
+            if (val.user_value->str() != nullptr && table->str() != nullptr) {
+              has_same_str =
+                  val.user_value->str()->str() == table->str()->str();
+            }
+            return (val.user_value->b() == table->b() &&
+                    val.user_value->f() == table->f() &&
+                    val.user_value->e() == table->e() && has_same_str);
+          },
+          IsTrue())));
+}
+
+TEST(FlatbuffersTableImplTest, EventuallyMutatesAllTableFields) {
+  auto domain = Arbitrary<SimpleTestFbsTable>();
+
+  absl::BitGen bitgen;
+  Value val(domain, bitgen);
+
+  const auto verify_field_changes = [&](std::string_view name, auto get) {
+    Set<decltype(get(val.user_value))> values;
+
+    int iterations = 10'000;
+    while (--iterations > 0 && values.size() < 2) {
+      values.insert(get(val.user_value));
+      val.Mutate(domain, bitgen, {}, false);
+    }
+    EXPECT_GT(iterations, 0)
+        << "Field: " << name << " -- " << testing::PrintToString(values);
+  };
+
+  verify_field_changes("b", [](auto v) { return v->b(); });
+  verify_field_changes("f", [](auto v) { return v->f(); });
+  verify_field_changes("str", [](auto v) { return v->str()->str(); });
+  verify_field_changes("e", [](auto v) { return v->e(); });
+}
+
+TEST(FlatbuffersTableImplTest, OptionalFieldsEventuallyBecomeEmpty) {
+  auto domain = Arbitrary<OptionalRequiredTestFbsTable>();
+
+  absl::BitGen bitgen;
+  Value val(domain, bitgen);
+
+  const auto verify_field_becomes_null = [&](std::string_view name, auto has) {
+    for (int i = 0; i < 10'000; ++i) {
+      val.Mutate(domain, bitgen, {}, false);
+      if (!has(val.user_value)) {
+        break;
+      }
+    }
+    EXPECT_FALSE(has(val.user_value)) << "Field never became unset: " << name;
+  };
+
+  verify_field_becomes_null("opt_scalar",
+                            [](auto v) { return v->opt_scalar().has_value(); });
+  verify_field_becomes_null("opt_str",
+                            [](auto v) { return v->opt_str() != nullptr; });
+}
+
+TEST(FlatbuffersTableImplTest, DefaultAndRequiredFieldsAlwaysSet) {
+  auto domain = Arbitrary<OptionalRequiredTestFbsTable>();
+
+  absl::BitGen bitgen;
+  Value val(domain, bitgen);
+
+  const auto verify_field_always_set = [&](std::string_view name, auto has) {
+    for (int i = 0; i < 10'000; ++i) {
+      val.Mutate(domain, bitgen, {}, false);
+      if (!has(val.user_value)) {
+        break;
+      }
+    }
+    EXPECT_TRUE(has(val.user_value)) << "Field is not set: " << name;
+  };
+
+  verify_field_always_set("def_scalar", [](auto v) { return true; });
+  verify_field_always_set("req_str",
+                          [](auto v) { return v->req_str() != nullptr; });
+}
+
+}  // namespace
+}  // namespace fuzztest

fuzztest/BUILD

@@ -345,6 +345,7 @@ cc_library(
         ":serialization",
         ":status",
         ":type_support",
+        "@abseil-cpp//absl/algorithm:container",
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:no_destructor",
         "@abseil-cpp//absl/container:flat_hash_map",
@@ -422,6 +423,35 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "flatbuffers",
+    srcs = ["internal/domains/flatbuffers_domain_impl.h"],
+    hdrs = ["flatbuffers.h"],
+    deps = [
+        ":any",
+        ":domain_core",
+        ":logging",
+        ":meta",
+        ":serialization",
+        ":status",
+        ":type_support",
+        "@abseil-cpp//absl/algorithm:container",
+        "@abseil-cpp//absl/base:core_headers",
+        "@abseil-cpp//absl/base:nullability",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/container:flat_hash_set",
+        "@abseil-cpp//absl/random",
+        "@abseil-cpp//absl/random:bit_gen_ref",
+        "@abseil-cpp//absl/random:distributions",
+        "@abseil-cpp//absl/status",
+        "@abseil-cpp//absl/status:statusor",
+        "@abseil-cpp//absl/strings",
+        "@abseil-cpp//absl/strings:str_format",
+        "@abseil-cpp//absl/synchronization",
+        "@flatbuffers//:runtime_cc",
+    ],
+)
+
 cc_library(
     name = "fixture_driver",
     srcs = ["internal/fixture_driver.cc"],
@@ -801,6 +831,28 @@ cc_proto_library(
     deps = [":test_protobuf"],
 )
 
+# Derived from //third_party/flatbuffers:flatbuffer_cc_library but allows output prefix for single
+# source target and to have embedded schema file in the outputs.
+genrule(
+    name = "test_flatbuffers_fbs",
+    srcs = ["internal/test_flatbuffers.fbs"],
+    outs = [
+        "internal/test_flatbuffers_bfbs_generated.h",
+        "internal/test_flatbuffers_generated.h",
+    ],
+    cmd = "$(location @flatbuffers//:flatc) -c -o $(@D)/internal --bfbs-gen-embed --gen-name-strings $(SRCS)",
+    message = "Generating flatbuffer files for test_flatbuffers_fbs",
+    tools = ["@flatbuffers//:flatc"],
+)
+
+cc_library(
+    name = "test_flatbuffers_cc_fbs",
+    srcs = [":test_flatbuffers_fbs"],
+    hdrs = [":test_flatbuffers_fbs"],
+    features = ["-parse_headers"],
+    deps = ["@flatbuffers//:runtime_cc"],
+)
+
 cc_library(
     name = "type_support",
     srcs = ["internal/type_support.cc"],