Add vector field support to FlatbuffersTableUntypedDomainImpl
PiperOrigin-RevId: 745927987
diff --git a/domain_tests/arbitrary_domains_flatbuffers_test.cc b/domain_tests/arbitrary_domains_flatbuffers_test.cc
index 3d397a2..c6565de 100644
--- a/domain_tests/arbitrary_domains_flatbuffers_test.cc
+++ b/domain_tests/arbitrary_domains_flatbuffers_test.cc
@@ -19,6 +19,7 @@
#include <cstring>
#include <optional>
#include <string>
+#include <type_traits>
#include <vector>
#include "gmock/gmock.h"
@@ -42,11 +43,19 @@
namespace {
using ::fuzztest::internal::BoolTable;
+using ::fuzztest::internal::ByteEnum;
using ::fuzztest::internal::DefaultTable;
+using ::fuzztest::internal::IntEnum;
+using ::fuzztest::internal::LongEnum;
using ::fuzztest::internal::OptionalTable;
using ::fuzztest::internal::RecursiveTable;
using ::fuzztest::internal::RequiredTable;
+using ::fuzztest::internal::ShortEnum;
+using ::fuzztest::internal::UByteEnum;
+using ::fuzztest::internal::UIntEnum;
+using ::fuzztest::internal::ULongEnum;
using ::fuzztest::internal::UnsupportedTypesTable;
+using ::fuzztest::internal::UShortEnum;
using ::testing::_;
using ::testing::AllOf;
using ::testing::Each;
@@ -82,6 +91,24 @@
return lhs.b() == rhs.b();
}
+template <typename T>
+inline bool VectorEq(const flatbuffers::Vector<T>& lhs,
+ const flatbuffers::Vector<T>& rhs) {
+ if (lhs.size() != rhs.size()) return false;
+ for (int i = 0; i < lhs.size(); ++i) {
+ if (!Eq(lhs.Get(i), rhs.Get(i))) return false;
+ }
+ return true;
+}
+
+template <typename T>
+inline bool VectorEq(const flatbuffers::Vector<T>* lhs,
+ const flatbuffers::Vector<T>* rhs) {
+ if (lhs == nullptr && rhs == nullptr) return true;
+ if (lhs == nullptr || rhs == nullptr) return false;
+ return VectorEq(*lhs, *rhs);
+}
+
template <>
inline bool Eq<DefaultTable>(const DefaultTable& lhs, const DefaultTable& rhs) {
const bool eq_b = lhs.b() == rhs.b();
@@ -105,14 +132,71 @@
const bool eq_eu32 = lhs.eu32() == rhs.eu32();
const bool eq_eu64 = lhs.eu64() == rhs.eu64();
const bool eq_t = Eq(lhs.t(), rhs.t());
+ const bool eq_v_b = VectorEq(lhs.v_b(), rhs.v_b());
+ const bool eq_v_i8 = VectorEq(lhs.v_i8(), rhs.v_i8());
+ const bool eq_v_i16 = VectorEq(lhs.v_i16(), rhs.v_i16());
+ const bool eq_v_i32 = VectorEq(lhs.v_i32(), rhs.v_i32());
+ const bool eq_v_i64 = VectorEq(lhs.v_i64(), rhs.v_i64());
+ const bool eq_v_u8 = VectorEq(lhs.v_u8(), rhs.v_u8());
+ const bool eq_v_u16 = VectorEq(lhs.v_u16(), rhs.v_u16());
+ const bool eq_v_u32 = VectorEq(lhs.v_u32(), rhs.v_u32());
+ const bool eq_v_u64 = VectorEq(lhs.v_u64(), rhs.v_u64());
+ const bool eq_v_f = VectorEq(lhs.v_f(), rhs.v_f());
+ const bool eq_v_d = VectorEq(lhs.v_d(), rhs.v_d());
+ const bool eq_v_str = VectorEq(lhs.v_str(), rhs.v_str());
+ const bool eq_v_ei8 = VectorEq(lhs.v_ei8(), rhs.v_ei8());
+ const bool eq_v_ei16 = VectorEq(lhs.v_ei16(), rhs.v_ei16());
+ const bool eq_v_ei32 = VectorEq(lhs.v_ei32(), rhs.v_ei32());
+ const bool eq_v_ei64 = VectorEq(lhs.v_ei64(), rhs.v_ei64());
+ const bool eq_v_eu8 = VectorEq(lhs.v_eu8(), rhs.v_eu8());
+ const bool eq_v_eu16 = VectorEq(lhs.v_eu16(), rhs.v_eu16());
+ const bool eq_v_eu32 = VectorEq(lhs.v_eu32(), rhs.v_eu32());
+ const bool eq_v_eu64 = VectorEq(lhs.v_eu64(), rhs.v_eu64());
+ const bool eq_v_t = VectorEq(lhs.v_t(), rhs.v_t());
return eq_b && eq_i8 && eq_i16 && eq_i32 && eq_i64 && eq_u8 && eq_u16 &&
eq_u32 && eq_u64 && eq_f && eq_d && eq_str && eq_ei8 && eq_ei16 &&
- eq_ei32 && eq_ei64 && eq_eu8 && eq_eu16 && eq_eu32 && eq_eu64 && eq_t;
+ eq_ei32 && eq_ei64 && eq_eu8 && eq_eu16 && eq_eu32 && eq_eu64 &&
+ eq_t && eq_v_b && eq_v_i8 && eq_v_i16 && eq_v_i32 && eq_v_i64 &&
+ eq_v_u8 && eq_v_u16 && eq_v_u32 && eq_v_u64 && eq_v_f && eq_v_d &&
+ eq_v_str && eq_v_ei8 && eq_v_ei16 && eq_v_ei32 && eq_v_ei64 &&
+ eq_v_eu8 && eq_v_eu16 && eq_v_eu32 && eq_v_eu64 && eq_v_t;
}
const internal::DefaultTable* CreateDefaultTable(
flatbuffers::FlatBufferBuilder& fbb) {
auto bool_table_offset = internal::CreateBoolTable(fbb, true);
+ std::vector<uint8_t> v_b{true, false};
+ std::vector<int8_t> v_i8{1, 2, 3};
+ std::vector<int16_t> v_i16{1, 2, 3};
+ std::vector<int32_t> v_i32{1, 2, 3};
+ std::vector<int64_t> v_i64{1, 2, 3};
+ std::vector<uint8_t> v_u8{1, 2, 3};
+ std::vector<uint16_t> v_u16{1, 2, 3};
+ std::vector<uint32_t> v_u32{1, 2, 3};
+ std::vector<uint64_t> v_u64{1, 2, 3};
+ std::vector<float> v_f{1, 2, 3};
+ std::vector<double> v_d{1, 2, 3};
+ std::vector<flatbuffers::Offset<flatbuffers::String>> v_str{
+ fbb.CreateString("foo"), fbb.CreateString("bar"),
+ fbb.CreateString("baz")};
+ std::vector<std::underlying_type_t<ByteEnum>> v_ei8{
+ internal::ByteEnum_First, internal::ByteEnum_Second};
+ std::vector<std::underlying_type_t<ShortEnum>> v_ei16{
+ internal::ShortEnum_First, internal::ShortEnum_Second};
+ std::vector<std::underlying_type_t<IntEnum>> v_ei32{internal::IntEnum_First,
+ internal::IntEnum_Second};
+ std::vector<std::underlying_type_t<LongEnum>> v_ei64{
+ internal::LongEnum_First, internal::LongEnum_Second};
+ std::vector<std::underlying_type_t<UByteEnum>> v_eu8{
+ internal::UByteEnum_First, internal::UByteEnum_Second};
+ std::vector<std::underlying_type_t<UShortEnum>> v_eu16{
+ internal::UShortEnum_First, internal::UShortEnum_Second};
+ std::vector<std::underlying_type_t<UIntEnum>> v_eu32{
+ internal::UIntEnum_First, internal::UIntEnum_Second};
+ std::vector<std::underlying_type_t<ULongEnum>> v_eu64{
+ internal::ULongEnum_First, internal::ULongEnum_Second};
+ std::vector<flatbuffers::Offset<BoolTable>> v_t{bool_table_offset};
+
auto table_offset =
internal::CreateDefaultTableDirect(fbb,
/*b=*/true,
@@ -135,7 +219,28 @@
/*eu16=*/internal::UShortEnum_Second,
/*eu32=*/internal::UIntEnum_Second,
/*eu64=*/internal::ULongEnum_Second,
- /*t=*/bool_table_offset);
+ /*t=*/bool_table_offset,
+ /*v_b=*/&v_b,
+ /*v_i8=*/&v_i8,
+ /*v_i16=*/&v_i16,
+ /*v_i32=*/&v_i32,
+ /*v_i64=*/&v_i64,
+ /*v_u8=*/&v_u8,
+ /*v_u16=*/&v_u16,
+ /*v_u32=*/&v_u32,
+ /*v_u64=*/&v_u64,
+ /*v_f=*/&v_f,
+ /*v_d=*/&v_d,
+ /*v_str=*/&v_str,
+ /*v_ei8=*/&v_ei8,
+ /*v_ei16=*/&v_ei16,
+ /*v_ei32=*/&v_ei32,
+ /*v_ei64=*/&v_ei64,
+ /*v_eu8=*/&v_eu8,
+ /*v_eu16=*/&v_eu16,
+ /*v_eu32=*/&v_eu32,
+ /*v_eu64=*/&v_eu64,
+ /*v_t=*/&v_t);
fbb.Finish(table_offset);
return flatbuffers::GetRoot<DefaultTable>(fbb.GetBufferPointer());
}
@@ -281,6 +386,96 @@
EXPECT_EQ(new_table->eu64(), internal::ULongEnum_Second);
ASSERT_THAT(new_table->t(), NotNull());
EXPECT_EQ(new_table->t()->b(), true);
+ ASSERT_THAT(new_table->v_b(), NotNull());
+ EXPECT_EQ(new_table->v_b()->size(), 2);
+ EXPECT_EQ(new_table->v_b()->Get(0), true);
+ EXPECT_EQ(new_table->v_b()->Get(1), false);
+ ASSERT_THAT(new_table->v_i8(), NotNull());
+ EXPECT_EQ(new_table->v_i8()->size(), 3);
+ EXPECT_EQ(new_table->v_i8()->Get(0), 1);
+ EXPECT_EQ(new_table->v_i8()->Get(1), 2);
+ EXPECT_EQ(new_table->v_i8()->Get(2), 3);
+ ASSERT_THAT(new_table->v_i16(), NotNull());
+ EXPECT_EQ(new_table->v_i16()->size(), 3);
+ EXPECT_EQ(new_table->v_i16()->Get(0), 1);
+ EXPECT_EQ(new_table->v_i16()->Get(1), 2);
+ EXPECT_EQ(new_table->v_i16()->Get(2), 3);
+ ASSERT_THAT(new_table->v_i32(), NotNull());
+ EXPECT_EQ(new_table->v_i32()->size(), 3);
+ EXPECT_EQ(new_table->v_i32()->Get(0), 1);
+ EXPECT_EQ(new_table->v_i32()->Get(1), 2);
+ EXPECT_EQ(new_table->v_i32()->Get(2), 3);
+ ASSERT_THAT(new_table->v_i64(), NotNull());
+ EXPECT_EQ(new_table->v_i64()->size(), 3);
+ EXPECT_EQ(new_table->v_i64()->Get(0), 1);
+ EXPECT_EQ(new_table->v_i64()->Get(1), 2);
+ EXPECT_EQ(new_table->v_i64()->Get(2), 3);
+ ASSERT_THAT(new_table->v_u8(), NotNull());
+ EXPECT_EQ(new_table->v_u8()->size(), 3);
+ EXPECT_EQ(new_table->v_u8()->Get(0), 1);
+ EXPECT_EQ(new_table->v_u8()->Get(1), 2);
+ EXPECT_EQ(new_table->v_u8()->Get(2), 3);
+ ASSERT_THAT(new_table->v_u16(), NotNull());
+ EXPECT_EQ(new_table->v_u16()->size(), 3);
+ EXPECT_EQ(new_table->v_u16()->Get(0), 1);
+ EXPECT_EQ(new_table->v_u16()->Get(1), 2);
+ EXPECT_EQ(new_table->v_u16()->Get(2), 3);
+ ASSERT_THAT(new_table->v_u32(), NotNull());
+ EXPECT_EQ(new_table->v_u32()->size(), 3);
+ EXPECT_EQ(new_table->v_u32()->Get(0), 1);
+ EXPECT_EQ(new_table->v_u32()->Get(1), 2);
+ EXPECT_EQ(new_table->v_u32()->Get(2), 3);
+ ASSERT_THAT(new_table->v_u64(), NotNull());
+ EXPECT_EQ(new_table->v_u64()->size(), 3);
+ EXPECT_EQ(new_table->v_u64()->Get(0), 1);
+ EXPECT_EQ(new_table->v_u64()->Get(1), 2);
+ EXPECT_EQ(new_table->v_u64()->Get(2), 3);
+ ASSERT_THAT(new_table->v_f(), NotNull());
+ EXPECT_EQ(new_table->v_f()->size(), 3);
+ EXPECT_EQ(new_table->v_f()->Get(0), 1);
+ EXPECT_EQ(new_table->v_f()->Get(1), 2);
+ EXPECT_EQ(new_table->v_f()->Get(2), 3);
+ ASSERT_THAT(new_table->v_d(), NotNull());
+ EXPECT_EQ(new_table->v_d()->size(), 3);
+ EXPECT_EQ(new_table->v_d()->Get(0), 1);
+ EXPECT_EQ(new_table->v_d()->Get(1), 2);
+ EXPECT_EQ(new_table->v_d()->Get(2), 3);
+ EXPECT_EQ(new_table->v_str()->size(), 3);
+ EXPECT_EQ(new_table->v_str()->Get(0)->str(), "foo");
+ EXPECT_EQ(new_table->v_str()->Get(1)->str(), "bar");
+ EXPECT_EQ(new_table->v_str()->Get(2)->str(), "baz");
+ ASSERT_THAT(new_table->v_ei8(), NotNull());
+ EXPECT_EQ(new_table->v_ei8()->size(), 2);
+ EXPECT_EQ(new_table->v_ei8()->Get(0), internal::ByteEnum_First);
+ EXPECT_EQ(new_table->v_ei8()->Get(1), internal::ByteEnum_Second);
+ ASSERT_THAT(new_table->v_ei16(), NotNull());
+ EXPECT_EQ(new_table->v_ei16()->size(), 2);
+ EXPECT_EQ(new_table->v_ei16()->Get(0), internal::ShortEnum_First);
+ EXPECT_EQ(new_table->v_ei16()->Get(1), internal::ShortEnum_Second);
+ ASSERT_THAT(new_table->v_ei32(), NotNull());
+ EXPECT_EQ(new_table->v_ei32()->size(), 2);
+ EXPECT_EQ(new_table->v_ei32()->Get(0), internal::IntEnum_First);
+ EXPECT_EQ(new_table->v_ei32()->Get(1), internal::IntEnum_Second);
+ ASSERT_THAT(new_table->v_ei64(), NotNull());
+ EXPECT_EQ(new_table->v_ei64()->size(), 2);
+ EXPECT_EQ(new_table->v_ei64()->Get(0), internal::LongEnum_First);
+ EXPECT_EQ(new_table->v_ei64()->Get(1), internal::LongEnum_Second);
+ ASSERT_THAT(new_table->v_eu8(), NotNull());
+ EXPECT_EQ(new_table->v_eu8()->size(), 2);
+ EXPECT_EQ(new_table->v_eu8()->Get(0), internal::UByteEnum_First);
+ EXPECT_EQ(new_table->v_eu8()->Get(1), internal::UByteEnum_Second);
+ ASSERT_THAT(new_table->v_eu16(), NotNull());
+ EXPECT_EQ(new_table->v_eu16()->size(), 2);
+ EXPECT_EQ(new_table->v_eu16()->Get(0), internal::UShortEnum_First);
+ EXPECT_EQ(new_table->v_eu16()->Get(1), internal::UShortEnum_Second);
+ ASSERT_THAT(new_table->v_eu32(), NotNull());
+ EXPECT_EQ(new_table->v_eu32()->size(), 2);
+ EXPECT_EQ(new_table->v_eu32()->Get(0), internal::UIntEnum_First);
+ EXPECT_EQ(new_table->v_eu32()->Get(1), internal::UIntEnum_Second);
+ ASSERT_THAT(new_table->v_t(), NotNull());
+ EXPECT_EQ(new_table->v_t()->size(), 1);
+ ASSERT_THAT(new_table->v_t()->Get(0), NotNull());
+ EXPECT_EQ(new_table->v_t()->Get(0)->b(), true);
}
TEST(FlatbuffersTableDomainImplTest, InitGeneratesSeeds) {
@@ -300,12 +495,17 @@
TEST(FlatbuffersTableDomainImplTest, CanMutateAnyTableField) {
absl::flat_hash_map<std::string, bool> mutated_fields{
- {"b", false}, {"i8", false}, {"i16", false}, {"i32", false},
- {"i64", false}, {"u8", false}, {"u16", false}, {"u32", false},
- {"u64", false}, {"f", false}, {"d", false}, {"str", false},
- {"ei8", false}, {"ei16", false}, {"ei32", false}, {"ei64", false},
- {"eu8", false}, {"eu16", false}, {"eu32", false}, {"eu64", false},
- {"t", false},
+ {"b", false}, {"i8", false}, {"i16", false}, {"i32", false},
+ {"i64", false}, {"u8", false}, {"u16", false}, {"u32", false},
+ {"u64", false}, {"f", false}, {"d", false}, {"str", false},
+ {"ei8", false}, {"ei16", false}, {"ei32", false}, {"ei64", false},
+ {"eu8", false}, {"eu16", false}, {"eu32", false}, {"eu64", false},
+ {"t", false}, {"v_b", false}, {"v_i8", false}, {"v_i16", false},
+ {"v_i32", false}, {"v_i64", false}, {"v_u8", false}, {"v_u16", false},
+ {"v_u32", false}, {"v_u64", false}, {"v_f", false}, {"v_d", false},
+ {"v_str", false}, {"v_ei8", false}, {"v_ei16", false}, {"v_ei32", false},
+ {"v_ei64", false}, {"v_eu8", false}, {"v_eu16", false}, {"v_eu32", false},
+ {"v_eu64", false}, {"v_t", false},
};
auto domain = Arbitrary<const DefaultTable*>();
@@ -341,6 +541,27 @@
mutated_fields["eu32"] |= mut->eu32() != init->eu32();
mutated_fields["eu64"] |= mut->eu64() != init->eu64();
mutated_fields["t"] |= !Eq(mut->t(), init->t());
+ mutated_fields["v_b"] |= !VectorEq(mut->v_b(), init->v_b());
+ mutated_fields["v_i8"] |= !VectorEq(mut->v_i8(), init->v_i8());
+ mutated_fields["v_i16"] |= !VectorEq(mut->v_i16(), init->v_i16());
+ mutated_fields["v_i32"] |= !VectorEq(mut->v_i32(), init->v_i32());
+ mutated_fields["v_i64"] |= !VectorEq(mut->v_i64(), init->v_i64());
+ mutated_fields["v_u8"] |= !VectorEq(mut->v_u8(), init->v_u8());
+ mutated_fields["v_u16"] |= !VectorEq(mut->v_u16(), init->v_u16());
+ mutated_fields["v_u32"] |= !VectorEq(mut->v_u32(), init->v_u32());
+ mutated_fields["v_u64"] |= !VectorEq(mut->v_u64(), init->v_u64());
+ mutated_fields["v_f"] |= !VectorEq(mut->v_f(), init->v_f());
+ mutated_fields["v_d"] |= !VectorEq(mut->v_d(), init->v_d());
+ mutated_fields["v_str"] |= !VectorEq(mut->v_str(), init->v_str());
+ mutated_fields["v_ei8"] |= !VectorEq(mut->v_ei8(), init->v_ei8());
+ mutated_fields["v_ei16"] |= !VectorEq(mut->v_ei16(), init->v_ei16());
+ mutated_fields["v_ei32"] |= !VectorEq(mut->v_ei32(), init->v_ei32());
+ mutated_fields["v_ei64"] |= !VectorEq(mut->v_ei64(), init->v_ei64());
+ mutated_fields["v_eu8"] |= !VectorEq(mut->v_eu8(), init->v_eu8());
+ mutated_fields["v_eu16"] |= !VectorEq(mut->v_eu16(), init->v_eu16());
+ mutated_fields["v_eu32"] |= !VectorEq(mut->v_eu32(), init->v_eu32());
+ mutated_fields["v_eu64"] |= !VectorEq(mut->v_eu64(), init->v_eu64());
+ mutated_fields["v_t"] |= !VectorEq(mut->v_str(), init->v_str());
if (std::all_of(mutated_fields.begin(), mutated_fields.end(),
[](const auto& p) { return p.second; })) {
@@ -354,6 +575,28 @@
TEST(FlatbuffersTableDomainImplTest, OptionalTableEventuallyBecomeEmpty) {
flatbuffers::FlatBufferBuilder fbb;
auto bool_table_offset = internal::CreateBoolTable(fbb, true);
+ std::vector<uint8_t> v_b{true, false};
+ std::vector<int8_t> v_i8{};
+ std::vector<int16_t> v_i16{};
+ std::vector<int32_t> v_i32{};
+ std::vector<int64_t> v_i64{};
+ std::vector<uint8_t> v_u8{};
+ std::vector<uint16_t> v_u16{};
+ std::vector<uint32_t> v_u32{};
+ std::vector<uint64_t> v_u64{};
+ std::vector<float> v_f{};
+ std::vector<double> v_d{};
+ std::vector<flatbuffers::Offset<flatbuffers::String>> v_str{
+ fbb.CreateString(""), fbb.CreateString(""), fbb.CreateString("")};
+ std::vector<std::underlying_type_t<ByteEnum>> v_ei8{};
+ std::vector<std::underlying_type_t<ShortEnum>> v_ei16{};
+ std::vector<std::underlying_type_t<IntEnum>> v_ei32{};
+ std::vector<std::underlying_type_t<LongEnum>> v_ei64{};
+ std::vector<std::underlying_type_t<UByteEnum>> v_eu8{};
+ std::vector<std::underlying_type_t<UShortEnum>> v_eu16{};
+ std::vector<std::underlying_type_t<UIntEnum>> v_eu32{};
+ std::vector<std::underlying_type_t<ULongEnum>> v_eu64{};
+ std::vector<flatbuffers::Offset<BoolTable>> v_t{};
auto table_offset =
internal::CreateOptionalTableDirect(fbb,
true, // b
@@ -376,7 +619,28 @@
internal::UShortEnum_Second, // eu16
internal::UIntEnum_Second, // eu32
internal::ULongEnum_Second, // eu64
- bool_table_offset // t
+ bool_table_offset, // t
+ &v_b, // v_b
+ &v_i8, // v_i8
+ &v_i16, // v_i16
+ &v_i32, // v_i32
+ &v_i64, // v_i64
+ &v_u8, // v_u8
+ &v_u16, // v_u16
+ &v_u32, // v_u32
+ &v_u64, // v_u64
+ &v_f, // v_f
+ &v_d, // v_d
+ &v_str, // v_str
+ &v_ei8, // v_ei8
+ &v_ei16, // v_ei16
+ &v_ei32, // v_ei32
+ &v_ei64, // v_ei64
+ &v_eu8, // v_eu8
+ &v_eu16, // v_eu16
+ &v_eu32, // v_eu32
+ &v_eu64, // v_eu64
+ &v_t // v_t
);
fbb.Finish(table_offset);
auto table = flatbuffers::GetRoot<OptionalTable>(fbb.GetBufferPointer());
@@ -386,12 +650,17 @@
absl::BitGen bitgen;
absl::flat_hash_map<std::string, bool> null_fields{
- {"b", false}, {"i8", false}, {"i16", false}, {"i32", false},
- {"i64", false}, {"u8", false}, {"u16", false}, {"u32", false},
- {"u64", false}, {"f", false}, {"d", false}, {"str", false},
- {"ei8", false}, {"ei16", false}, {"ei32", false}, {"ei64", false},
- {"eu8", false}, {"eu16", false}, {"eu32", false}, {"eu64", false},
- {"t", false},
+ {"b", false}, {"i8", false}, {"i16", false}, {"i32", false},
+ {"i64", false}, {"u8", false}, {"u16", false}, {"u32", false},
+ {"u64", false}, {"f", false}, {"d", false}, {"str", false},
+ {"ei8", false}, {"ei16", false}, {"ei32", false}, {"ei64", false},
+ {"eu8", false}, {"eu16", false}, {"eu32", false}, {"eu64", false},
+ {"t", false}, {"v_b", false}, {"v_i8", false}, {"v_i16", false},
+ {"v_i32", false}, {"v_i64", false}, {"v_u8", false}, {"v_u16", false},
+ {"v_u32", false}, {"v_u64", false}, {"v_f", false}, {"v_d", false},
+ {"v_str", false}, {"v_ei8", false}, {"v_ei16", false}, {"v_ei32", false},
+ {"v_ei64", false}, {"v_eu8", false}, {"v_eu16", false}, {"v_eu32", false},
+ {"v_eu64", false}, {"v_t", false},
};
// Optional fields are mutated to null with probability 1/100.
@@ -422,6 +691,27 @@
null_fields["eu32"] |= !v->eu32().has_value();
null_fields["eu64"] |= !v->eu64().has_value();
null_fields["t"] |= v->t() == nullptr;
+ null_fields["v_b"] |= v->v_b() == nullptr;
+ null_fields["v_i8"] |= v->v_i8() == nullptr;
+ null_fields["v_i16"] |= v->v_i16() == nullptr;
+ null_fields["v_i32"] |= v->v_i32() == nullptr;
+ null_fields["v_i64"] |= v->v_i64() == nullptr;
+ null_fields["v_u8"] |= v->v_u8() == nullptr;
+ null_fields["v_u16"] |= v->v_u16() == nullptr;
+ null_fields["v_u32"] |= v->v_u32() == nullptr;
+ null_fields["v_u64"] |= v->v_u64() == nullptr;
+ null_fields["v_f"] |= v->v_f() == nullptr;
+ null_fields["v_d"] |= v->v_d() == nullptr;
+ null_fields["v_str"] |= v->v_str() == nullptr;
+ null_fields["v_ei8"] |= v->v_ei8() == nullptr;
+ null_fields["v_ei16"] |= v->v_ei16() == nullptr;
+ null_fields["v_ei32"] |= v->v_ei32() == nullptr;
+ null_fields["v_ei64"] |= v->v_ei64() == nullptr;
+ null_fields["v_eu8"] |= v->v_eu8() == nullptr;
+ null_fields["v_eu16"] |= v->v_eu16() == nullptr;
+ null_fields["v_eu32"] |= v->v_eu32() == nullptr;
+ null_fields["v_eu64"] |= v->v_eu64() == nullptr;
+ null_fields["v_t"] |= v->v_t() == nullptr;
if (std::all_of(null_fields.begin(), null_fields.end(),
[](const auto& p) { return p.second; })) {
@@ -460,39 +750,55 @@
printer.PrintCorpusValue(*corpus, &out,
domain_implementor::PrintMode::kHumanReadable);
- EXPECT_THAT(out, AllOf(HasSubstr("b: (true)"), // b
- HasSubstr("i8: (1)"), // i8
- HasSubstr("i16: (2)"), // i16
- HasSubstr("i32: (3)"), // i32
- HasSubstr("i64: (4)"), // i64
- HasSubstr("u8: (5)"), // u8
- HasSubstr("u16: (6)"), // u16
- HasSubstr("u32: (7)"), // u32
- HasSubstr("u64: (8)"), // u64
- HasSubstr("f: (9.f)"), // f
- HasSubstr("d: (10.)"), // d
- HasSubstr("str: (\"foo bar baz\")"), // str
- HasSubstr("ei8: (Second)"), // ei8
- HasSubstr("ei16: (Second)"), // ei16
- HasSubstr("ei32: (Second)"), // ei32
- HasSubstr("ei64: (Second)"), // ei64
- HasSubstr("eu8: (Second)"), // eu8
- HasSubstr("eu16: (Second)"), // eu16
- HasSubstr("eu32: (Second)"), // eu32
- HasSubstr("eu64: (Second)"), // eu64
- HasSubstr("t: ({b: (true)})") // t
- ));
+ EXPECT_THAT(out,
+ AllOf(HasSubstr("b: (true)"), // b
+ HasSubstr("i8: (1)"), // i8
+ HasSubstr("i16: (2)"), // i16
+ HasSubstr("i32: (3)"), // i32
+ HasSubstr("i64: (4)"), // i64
+ HasSubstr("u8: (5)"), // u8
+ HasSubstr("u16: (6)"), // u16
+ HasSubstr("u32: (7)"), // u32
+ HasSubstr("u64: (8)"), // u64
+ HasSubstr("f: (9.f)"), // f
+ HasSubstr("d: (10.)"), // d
+ HasSubstr("str: (\"foo bar baz\")"), // str
+ HasSubstr("ei8: (Second)"), // ei8
+ HasSubstr("ei16: (Second)"), // ei16
+ HasSubstr("ei32: (Second)"), // ei32
+ HasSubstr("ei64: (Second)"), // ei64
+ HasSubstr("eu8: (Second)"), // eu8
+ HasSubstr("eu16: (Second)"), // eu16
+ HasSubstr("eu32: (Second)"), // eu32
+ HasSubstr("eu64: (Second)"), // eu64
+ HasSubstr("t: ({b: (true)})"), // t
+ HasSubstr("v_b: ({true, false})"), // v_b
+ HasSubstr("v_i8: ({1, 2, 3})"), // v_i8
+ HasSubstr("v_i16: ({1, 2, 3})"), // v_i16
+ HasSubstr("v_i32: ({1, 2, 3})"), // v_i32
+ HasSubstr("v_i64: ({1, 2, 3})"), // v_i64
+ HasSubstr("v_u8: ({1, 2, 3})"), // v_u8
+ HasSubstr("v_u16: ({1, 2, 3})"), // v_u16
+ HasSubstr("v_u32: ({1, 2, 3})"), // v_u32
+ HasSubstr("v_u64: ({1, 2, 3})"), // v_u64
+ HasSubstr("v_f: ({1.f, 2.f, 3.f})"), // v_f
+ HasSubstr("v_d: ({1., 2., 3.})"), // v_d
+ HasSubstr("v_str: ({\"foo\", \"bar\", \"baz\"})"), // v_str
+ HasSubstr("v_ei8: ({First, Second})"), // v_ei8
+ HasSubstr("v_ei16: ({First, Second})"), // v_ei16
+ HasSubstr("v_ei32: ({First, Second})"), // v_ei32
+ HasSubstr("v_ei64: ({First, Second})"), // v_ei64
+ HasSubstr("v_eu8: ({First, Second})"), // v_eu8
+ HasSubstr("v_eu16: ({First, Second})"), // v_eu16
+ HasSubstr("v_eu32: ({First, Second})"), // v_eu32
+ HasSubstr("v_eu64: ({First, Second})"), // v_eu64
+ HasSubstr("v_t: ({{b: (true)}})") // v_t
+ ));
}
TEST(FlatbuffersTableDomainImplTest, UnsupportedTypesRemainNull) {
absl::flat_hash_map<std::string, bool> null_fields{
- {"u", true}, {"s", true}, {"v_b", true}, {"v_i8", true},
- {"v_i16", true}, {"v_i32", true}, {"v_i64", true}, {"v_u8", true},
- {"v_u16", true}, {"v_u32", true}, {"v_u64", true}, {"v_f", true},
- {"v_d", true}, {"v_str", true}, {"v_ei8", true}, {"v_ei16", true},
- {"v_ei32", true}, {"v_ei64", true}, {"v_eu8", true}, {"v_eu16", true},
- {"v_eu32", true}, {"v_eu64", true}, {"v_t", true}, {"v_u", true},
- {"v_s", true}};
+ {"u", true}, {"s", true}, {"v_u", true}, {"v_s", true}};
auto domain = Arbitrary<const UnsupportedTypesTable*>();
@@ -506,27 +812,6 @@
null_fields["u"] &= mut->u() == nullptr;
null_fields["s"] &= mut->s() == nullptr;
- null_fields["v_b"] &= mut->v_b() == nullptr;
- null_fields["v_i8"] &= mut->v_i8() == nullptr;
- null_fields["v_i16"] &= mut->v_i16() == nullptr;
- null_fields["v_i32"] &= mut->v_i32() == nullptr;
- null_fields["v_i64"] &= mut->v_i64() == nullptr;
- null_fields["v_u8"] &= mut->v_u8() == nullptr;
- null_fields["v_u16"] &= mut->v_u16() == nullptr;
- null_fields["v_u32"] &= mut->v_u32() == nullptr;
- null_fields["v_u64"] &= mut->v_u64() == nullptr;
- null_fields["v_f"] &= mut->v_f() == nullptr;
- null_fields["v_d"] &= mut->v_d() == nullptr;
- null_fields["v_str"] &= mut->v_str() == nullptr;
- null_fields["v_ei8"] &= mut->v_ei8() == nullptr;
- null_fields["v_ei16"] &= mut->v_ei16() == nullptr;
- null_fields["v_ei32"] &= mut->v_ei32() == nullptr;
- null_fields["v_ei64"] &= mut->v_ei64() == nullptr;
- null_fields["v_eu8"] &= mut->v_eu8() == nullptr;
- null_fields["v_eu16"] &= mut->v_eu16() == nullptr;
- null_fields["v_eu32"] &= mut->v_eu32() == nullptr;
- null_fields["v_eu64"] &= mut->v_eu64() == nullptr;
- null_fields["v_t"] &= mut->v_t() == nullptr;
null_fields["v_u"] &= mut->v_u() == nullptr;
null_fields["v_s"] &= mut->v_s() == nullptr;
@@ -573,7 +858,7 @@
auto domain = Arbitrary<const OptionalTable*>();
auto corpus = domain.FromValue(table);
ASSERT_TRUE(corpus.has_value());
- EXPECT_EQ(domain.CountNumberOfFields(corpus.value()), 21);
+ EXPECT_EQ(domain.CountNumberOfFields(corpus.value()), 42);
}
TEST(FlatbuffersTableDomainImplTest, RecursiveTable) {
diff --git a/fuzztest/internal/domains/flatbuffers_domain_impl.cc b/fuzztest/internal/domains/flatbuffers_domain_impl.cc
index 1a94bbf..51b29bb 100644
--- a/fuzztest/internal/domains/flatbuffers_domain_impl.cc
+++ b/fuzztest/internal/domains/flatbuffers_domain_impl.cc
@@ -137,7 +137,9 @@
}
field_counter++;
- if (field->type()->base_type() == reflection::BaseType::Obj) {
+ auto base_type = field->type()->base_type();
+
+ if (base_type == reflection::BaseType::Obj) {
auto sub_object = schema_->objects()->Get(field->type()->index());
if (!sub_object->is_struct()) {
field_counter +=
@@ -148,6 +150,21 @@
// TODO: Add support for structs.
}
+ if (base_type == reflection::BaseType::Vector ||
+ base_type == reflection::BaseType::Vector64) {
+ auto elem_type = field->type()->element();
+ if (elem_type == reflection::BaseType::Obj) {
+ auto sub_object = schema_->objects()->Get(field->type()->index());
+ if (!sub_object->is_struct()) {
+ field_counter +=
+ GetCachedDomain<FlatbuffersVectorTag<FlatbuffersTableTag>>(field)
+ .MutateSelectedField(val[field->id()], prng, metadata,
+ only_shrink,
+ selected_field_index - field_counter);
+ }
+ }
+ }
+
if (field_counter > selected_field_index) {
return field_counter;
}
@@ -266,6 +283,16 @@
auto sub_object = schema_->objects()->Get(field->type()->index());
return !sub_object->is_struct();
};
+ if (base_type == reflection::BaseType::Vector ||
+ base_type == reflection::BaseType::Vector64) {
+ auto elem_type = field->type()->element();
+ if (flatbuffers::IsScalar(elem_type)) return true;
+ if (elem_type == reflection::BaseType::String) return true;
+ if (elem_type == reflection::BaseType::Obj) {
+ auto sub_object = schema_->objects()->Get(field->type()->index());
+ return !sub_object->is_struct();
+ }
+ }
return false;
}
diff --git a/fuzztest/internal/domains/flatbuffers_domain_impl.h b/fuzztest/internal/domains/flatbuffers_domain_impl.h
index 23f6bd6..eacb756 100644
--- a/fuzztest/internal/domains/flatbuffers_domain_impl.h
+++ b/fuzztest/internal/domains/flatbuffers_domain_impl.h
@@ -20,6 +20,7 @@
#include <cstdint>
#include <initializer_list>
#include <limits>
+#include <list>
#include <optional>
#include <string>
#include <type_traits>
@@ -42,10 +43,12 @@
#include "flatbuffers/reflection_generated.h"
#include "flatbuffers/string.h"
#include "flatbuffers/table.h"
+#include "flatbuffers/vector.h"
#include "flatbuffers/verifier.h"
#include "./fuzztest/domain_core.h"
#include "./fuzztest/internal/any.h"
#include "./fuzztest/internal/domains/arbitrary_impl.h"
+#include "./fuzztest/internal/domains/container_of_impl.h"
#include "./fuzztest/internal/domains/domain_base.h"
#include "./fuzztest/internal/domains/domain_type_erasure.h"
#include "./fuzztest/internal/domains/element_of_impl.h"
@@ -53,6 +56,7 @@
#include "./fuzztest/internal/meta.h"
#include "./fuzztest/internal/serialization.h"
#include "./fuzztest/internal/status.h"
+#include "./fuzztest/internal/type_support.h"
namespace fuzztest::internal {
@@ -77,11 +81,141 @@
inline constexpr bool is_flatbuffers_enum_tag_v =
is_flatbuffers_enum_tag<T>::value;
+//
+// Flatbuffers vector detection.
+//
+template <typename T>
+struct FlatbuffersVectorTag {
+ using value_type = T;
+};
+
+template <typename T>
+struct is_flatbuffers_vector_tag : std::false_type {};
+
+template <typename T>
+struct is_flatbuffers_vector_tag<FlatbuffersVectorTag<T>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_flatbuffers_vector_tag_v =
+ is_flatbuffers_vector_tag<T>::value;
+
struct FlatbuffersArrayTag;
struct FlatbuffersTableTag;
struct FlatbuffersStructTag;
struct FlatbuffersUnionTag;
-struct FlatbuffersVectorTag;
+
+// Dynamic to static dispatch visitor pattern for flatbuffers vector elements.
+template <typename Visitor>
+auto VisitFlatbufferVectorElementField(const reflection::Schema* schema,
+ const reflection::Field* field,
+ Visitor visitor) {
+ auto field_index = field->type()->index();
+ auto element_type = field->type()->element();
+ switch (element_type) {
+ case reflection::BaseType::Bool:
+ visitor.template Visit<FlatbuffersVectorTag<bool>>(field);
+ break;
+ case reflection::BaseType::Byte:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<int8_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<int8_t>>(field);
+ }
+ break;
+ case reflection::BaseType::Short:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<int16_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<int16_t>>(field);
+ }
+ break;
+ case reflection::BaseType::Int:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<int32_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<int32_t>>(field);
+ }
+ break;
+ case reflection::BaseType::Long:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<int64_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<int64_t>>(field);
+ }
+ break;
+ case reflection::BaseType::UByte:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<uint8_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<uint8_t>>(field);
+ }
+ break;
+ case reflection::BaseType::UShort:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<uint16_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<uint16_t>>(field);
+ }
+ break;
+ case reflection::BaseType::UInt:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<uint32_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<uint32_t>>(field);
+ }
+ break;
+ case reflection::BaseType::ULong:
+ if (field_index >= 0) {
+ visitor
+ .template Visit<FlatbuffersVectorTag<FlatbuffersEnumTag<uint64_t>>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<uint64_t>>(field);
+ }
+ break;
+ case reflection::BaseType::Float:
+ visitor.template Visit<FlatbuffersVectorTag<float>>(field);
+ break;
+ case reflection::BaseType::Double:
+ visitor.template Visit<FlatbuffersVectorTag<double>>(field);
+ break;
+ case reflection::BaseType::String:
+ visitor.template Visit<FlatbuffersVectorTag<std::string>>(field);
+ break;
+ case reflection::BaseType::Obj: {
+ auto sub_object = schema->objects()->Get(field_index);
+ if (sub_object->is_struct()) {
+ visitor.template Visit<FlatbuffersVectorTag<FlatbuffersStructTag>>(
+ field);
+ } else {
+ visitor.template Visit<FlatbuffersVectorTag<FlatbuffersTableTag>>(
+ field);
+ }
+ break;
+ }
+ case reflection::BaseType::Union:
+ visitor.template Visit<FlatbuffersVectorTag<FlatbuffersUnionTag>>(field);
+ break;
+ case reflection::BaseType::UType:
+ break;
+ default: // Vector of vectors and vector of arrays are not supported.
+ FUZZTEST_INTERNAL_CHECK(false, "Unsupported vector base type");
+ }
+}
// Dynamic to static dispatch visitor pattern.
template <typename Visitor>
@@ -160,7 +294,7 @@
break;
case reflection::BaseType::Vector:
case reflection::BaseType::Vector64:
- visitor.template Visit<FlatbuffersVectorTag>(field);
+ VisitFlatbufferVectorElementField<Visitor>(schema, field, visitor);
break;
case reflection::BaseType::Array:
visitor.template Visit<FlatbuffersArrayTag>(field);
@@ -297,7 +431,7 @@
// Domain implementation for flatbuffers untyped tables.
// The corpus type is a map of field ids to field values.
class FlatbuffersTableUntypedDomainImpl
- : public fuzztest::domain_implementor::DomainBase<
+ : public domain_implementor::DomainBase<
/*Derived=*/FlatbuffersTableUntypedDomainImpl,
/*ValueType=*/const flatbuffers::Table* absl_nonnull,
/*CorpusType=*/
@@ -462,6 +596,56 @@
"Field must be a table type.");
inner_value =
user_value->GetPointer<const flatbuffers::Table*>(field->offset());
+ } else if constexpr (is_flatbuffers_vector_tag_v<T>) {
+ FUZZTEST_INTERNAL_CHECK(base_type == reflection::BaseType::Vector ||
+ base_type == reflection::BaseType::Vector64,
+ "Field must be a vector type.");
+ if (!user_value->CheckField(field->offset())) {
+ inner_value = std::nullopt;
+ } else {
+ using ElementType = typename T::value_type;
+ if constexpr (std::is_integral_v<ElementType> ||
+ std::is_floating_point_v<ElementType>) {
+ auto vec =
+ user_value->GetPointer<flatbuffers::Vector<ElementType>*>(
+ field->offset());
+ inner_value = std::optional(std::vector<ElementType>());
+ inner_value->reserve(vec->size());
+ for (auto i = 0; i < vec->size(); ++i) {
+ inner_value->push_back(vec->Get(i));
+ }
+ } else if constexpr (is_flatbuffers_enum_tag_v<ElementType>) {
+ using Underlaying = typename ElementType::type;
+ auto vec =
+ user_value->GetPointer<flatbuffers::Vector<Underlaying>*>(
+ field->offset());
+ inner_value = std::optional(std::vector<Underlaying>());
+ inner_value->reserve(vec->size());
+ for (auto i = 0; i < vec->size(); ++i) {
+ inner_value->push_back(vec->Get(i));
+ }
+ } else if constexpr (std::is_same_v<ElementType, std::string>) {
+ auto vec = user_value->GetPointer<
+ flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(
+ field->offset());
+ inner_value = std::optional(std::vector<std::string>());
+ inner_value->reserve(vec->size());
+ for (auto i = 0; i < vec->size(); ++i) {
+ inner_value->push_back(vec->Get(i)->str());
+ }
+ } else if constexpr (std::is_same_v<ElementType,
+ FlatbuffersTableTag>) {
+ auto vec = user_value->GetPointer<
+ flatbuffers::Vector<flatbuffers::Offset<flatbuffers::Table>>*>(
+ field->offset());
+ inner_value =
+ std::optional(std::vector<const flatbuffers::Table*>());
+ inner_value->reserve(vec->size());
+ for (auto i = 0; i < vec->size(); ++i) {
+ inner_value->push_back(vec->Get(i));
+ }
+ }
+ }
}
auto inner = domain.FromValue(inner_value);
@@ -492,18 +676,69 @@
} else if constexpr (std::is_same_v<T, FlatbuffersTableTag>) {
FlatbuffersTableUntypedDomainImpl inner_domain(
self.schema_, self.schema_->objects()->Get(field->type()->index()));
- auto optional_corpus = corpus_value.GetAs<
- std::variant<std::monostate, fuzztest::GenericDomainCorpusType>>();
- if (std::holds_alternative<fuzztest::GenericDomainCorpusType>(
- optional_corpus)) {
- auto inner_corpus =
- std::get<fuzztest::GenericDomainCorpusType>(optional_corpus)
- .GetAs<corpus_type>();
+ auto optional_corpus =
+ corpus_value
+ .GetAs<std::variant<std::monostate, GenericDomainCorpusType>>();
+ if (std::holds_alternative<GenericDomainCorpusType>(optional_corpus)) {
+ auto inner_corpus = std::get<GenericDomainCorpusType>(optional_corpus)
+ .GetAs<corpus_type>();
auto offset = inner_domain.BuildTable(inner_corpus, builder);
offsets.insert({field->id(), offset});
}
// Else if the variant is std::monostate the optional field is null and
// there is no table to build.
+ } else if constexpr (is_flatbuffers_vector_tag_v<T>) {
+ VisitVector<typename T::value_type>(field,
+ self.GetCachedDomain<T>(field));
+ }
+ }
+
+ private:
+ template <typename Element, typename Domain>
+ void VisitVector(const reflection::Field* field,
+ const Domain& domain) const {
+ if constexpr (std::is_integral_v<Element> ||
+ std::is_floating_point_v<Element>) {
+ auto value = domain.GetValue(corpus_value);
+ if (!value) {
+ return;
+ }
+ offsets.insert({field->id(), builder.CreateVector(*value).o});
+ } else if constexpr (is_flatbuffers_enum_tag_v<Element>) {
+ auto value = domain.GetValue(corpus_value);
+ if (!value) {
+ return;
+ }
+ offsets.insert({field->id(), builder.CreateVector(*value).o});
+ }
+ if constexpr (std::is_same_v<Element, FlatbuffersTableTag>) {
+ FlatbuffersTableUntypedDomainImpl domain(
+ self.schema_, self.schema_->objects()->Get(field->type()->index()));
+ auto opt_corpus =
+ corpus_value
+ .GetAs<std::variant<std::monostate, GenericDomainCorpusType>>();
+ if (std::holds_alternative<std::monostate>(opt_corpus)) {
+ return;
+ }
+ auto container_corpus = std::get<GenericDomainCorpusType>(opt_corpus)
+ .GetAs<std::list<corpus_type>>();
+ std::vector<flatbuffers::Offset<flatbuffers::Table>> vec_offsets;
+ for (auto& inner_corpus : container_corpus) {
+ auto offset = domain.BuildTable(inner_corpus, builder);
+ vec_offsets.push_back(offset);
+ }
+ offsets.insert({field->id(), builder.CreateVector(vec_offsets).o});
+ } else if constexpr (std::is_same_v<Element, std::string>) {
+ auto value = domain.GetValue(corpus_value);
+ if (!value) {
+ return;
+ }
+ std::vector<flatbuffers::Offset<flatbuffers::String>> vec_offsets;
+ for (const auto& str : *value) {
+ auto offset = builder.CreateString(str);
+ vec_offsets.push_back(offset);
+ }
+ offsets.insert({field->id(), builder.CreateVector(vec_offsets).o});
}
}
};
@@ -513,8 +748,8 @@
struct TableBuilderVisitor {
const FlatbuffersTableUntypedDomainImpl& self;
flatbuffers::FlatBufferBuilder& builder;
- const absl::flat_hash_map<typename corpus_type::key_type,
- flatbuffers::uoffset_t>& offsets;
+ absl::flat_hash_map<typename corpus_type::key_type, flatbuffers::uoffset_t>&
+ offsets;
const typename corpus_type::value_type::second_type& corpus_value;
template <typename T>
@@ -528,7 +763,8 @@
}
// Store "inline field" value inline.
builder.AddElement(field->offset(), v.value());
- } else if constexpr (std::is_same_v<T, std::string>) {
+ } else if constexpr (std::is_same_v<T, std::string> ||
+ is_flatbuffers_vector_tag_v<T>) {
// "Out-of-line field". Store just offset.
if (auto it = offsets.find(field->id()); it != offsets.end()) {
builder.AddOffset(
@@ -633,7 +869,6 @@
domain_implementor::RawSink out,
domain_implementor::PrintMode mode) const {
std::vector<typename corpus_type::key_type> field_ids;
- field_ids.reserve(value.size());
for (const auto& [id, _] : value) {
field_ids.push_back(id);
}
@@ -669,7 +904,49 @@
void Visit(const reflection::Field* absl_nonnull field) const {
auto& domain = self.GetCachedDomain<T>(field);
absl::Format(out, "%s: ", field->name()->str());
- domain_implementor::PrintValue(domain, val, out, mode);
+ if constexpr (std::is_same_v<T, FlatbuffersVectorTag<uint8_t>> ||
+ std::is_same_v<
+ T, FlatbuffersVectorTag<FlatbuffersEnumTag<uint8_t>>>) {
+ // Handle the case where the field is a vector<uint8_t> or enum<uint8_t>
+ // since the container domain would try to print it as a string.
+ auto opt_corpus =
+ val.GetAs<std::variant<std::monostate, GenericDomainCorpusType>>();
+ if (std::holds_alternative<GenericDomainCorpusType>(opt_corpus)) {
+ absl::Format(out, "(");
+ if constexpr (std::is_same_v<T, FlatbuffersVectorTag<uint8_t>>) {
+ auto inner_corpus =
+ std::get<GenericDomainCorpusType>(opt_corpus)
+ .GetAs<corpus_type_t<ContainerOfImpl<
+ std::vector<uint8_t>, ArbitraryImpl<uint8_t>>>>();
+ auto inner_domain = Arbitrary<uint8_t>();
+ auto printer = ContainerPrinter<
+ ContainerOfImpl<std::vector<uint8_t>, ArbitraryImpl<uint8_t>>,
+ ArbitraryImpl<uint8_t>>{inner_domain};
+ printer.PrintCorpusValue(inner_corpus, out, mode);
+ } else if constexpr (std::is_same_v<
+ T, FlatbuffersVectorTag<
+ FlatbuffersEnumTag<uint8_t>>>) {
+ auto inner_corpus =
+ std::get<GenericDomainCorpusType>(opt_corpus)
+ .GetAs<corpus_type_t<
+ ContainerOfImpl<std::vector<uint8_t>,
+ FlatbuffersEnumDomainImpl<uint8_t>>>>();
+ auto enum_object =
+ self.schema_->enums()->Get(field->type()->index());
+ auto inner_domain = FlatbuffersEnumDomainImpl<uint8_t>(enum_object);
+ auto printer = ContainerPrinter<
+ ContainerOfImpl<std::vector<uint8_t>,
+ FlatbuffersEnumDomainImpl<uint8_t>>,
+ FlatbuffersEnumDomainImpl<uint8_t>>{inner_domain};
+ printer.PrintCorpusValue(inner_corpus, out, mode);
+ }
+ absl::Format(out, ")");
+ } else {
+ absl::Format(out, "std::nullopt");
+ }
+ } else {
+ domain.GetPrinter().PrintCorpusValue(val, out, mode);
+ }
}
};
};
@@ -696,9 +973,9 @@
} else if constexpr (std::is_same_v<T, FlatbuffersUnionTag>) {
// TODO: support unions.
return placeholder;
- } else if constexpr (std::is_same_v<T, FlatbuffersVectorTag>) {
- // TODO: support vectors.
- return placeholder;
+ } else if constexpr (is_flatbuffers_vector_tag_v<T>) {
+ return VectorOf(GetDefaultDomain<typename T::value_type>(schema, field))
+ .WithMaxSize(std::numeric_limits<flatbuffers::uoffset_t>::max());
} else {
return Arbitrary<T>();
}
@@ -718,7 +995,7 @@
// - The serialized buffer of the table.
template <typename T>
class FlatbuffersTableDomainImpl
- : public fuzztest::domain_implementor::DomainBase<
+ : public domain_implementor::DomainBase<
/*Derived=*/FlatbuffersTableDomainImpl<T>,
/*ValueType=*/const T*,
/*CorpusType=*/FlatbuffersTableDomainCorpusType> {
diff --git a/fuzztest/internal/test_flatbuffers.fbs b/fuzztest/internal/test_flatbuffers.fbs
index 02177c0..b83ae18 100644
--- a/fuzztest/internal/test_flatbuffers.fbs
+++ b/fuzztest/internal/test_flatbuffers.fbs
@@ -78,6 +78,27 @@
eu32: UIntEnum;
eu64: ULongEnum;
t: BoolTable;
+ v_b: [bool];
+ v_i8: [byte];
+ v_i16: [short];
+ v_i32: [int];
+ v_i64: [long];
+ v_u8: [ubyte];
+ v_u16: [ushort];
+ v_u32: [uint];
+ v_u64: [ulong];
+ v_f: [float];
+ v_d: [double];
+ v_str: [string];
+ v_ei8: [ByteEnum];
+ v_ei16: [ShortEnum];
+ v_ei32: [IntEnum];
+ v_ei64: [LongEnum];
+ v_eu8: [UByteEnum];
+ v_eu16: [UShortEnum];
+ v_eu32: [UIntEnum];
+ v_eu64: [ULongEnum];
+ v_t: [BoolTable];
}
table OptionalTable {
@@ -102,24 +123,6 @@
eu32: UIntEnum = null;
eu64: ULongEnum = null;
t: BoolTable;
-}
-
-table RequiredTable {
- str: string (required);
- t: BoolTable (required);
-}
-
-table RecursiveTable {
- t: NestedRecursiveTable;
-}
-
-table NestedRecursiveTable {
- t: RecursiveTable;
-}
-
-table UnsupportedTypesTable {
- u: Union;
- s: BoolStruct;
v_b: [bool];
v_i8: [byte];
v_i16: [short];
@@ -141,6 +144,45 @@
v_eu32: [UIntEnum];
v_eu64: [ULongEnum];
v_t: [BoolTable];
+}
+
+table RequiredTable {
+ str: string (required);
+ t: BoolTable (required);
+ v_b: [bool] (required);
+ v_i8: [byte] (required);
+ v_i16: [short] (required);
+ v_i32: [int] (required);
+ v_i64: [long] (required);
+ v_u8: [ubyte] (required);
+ v_u16: [ushort] (required);
+ v_u32: [uint] (required);
+ v_u64: [ulong] (required);
+ v_f: [float] (required);
+ v_d: [double] (required);
+ v_str: [string] (required);
+ v_ei8: [ByteEnum] (required);
+ v_ei16: [ShortEnum] (required);
+ v_ei32: [IntEnum] (required);
+ v_ei64: [LongEnum] (required);
+ v_eu8: [UByteEnum] (required);
+ v_eu16: [UShortEnum] (required);
+ v_eu32: [UIntEnum] (required);
+ v_eu64: [ULongEnum] (required);
+ v_t: [BoolTable] (required);
+}
+
+table RecursiveTable {
+ t: NestedRecursiveTable;
+}
+
+table NestedRecursiveTable {
+ t: RecursiveTable;
+}
+
+table UnsupportedTypesTable {
+ u: Union;
+ s: BoolStruct;
v_u: [Union];
v_s: [BoolStruct];
}
