| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include <fidl/test/union/cpp/fidl.h> |
| |
| #include "lib/fidl/cpp/fuzzing/traits.h" |
| #include "lib/fidl/cpp/internal/header.h" |
| // For ::std::max_element(). |
| #include <algorithm> |
| // For uint64_t. |
| #include <stdint.h> |
| |
| namespace fuzzing { |
| |
| using Union = ::fidl::test::union_::Union; |
| using StructWithNullableXUnion = ::fidl::test::union_::StructWithNullableXUnion; |
| using StrictUnion = ::fidl::test::union_::StrictUnion; |
| using StrictSimpleXUnion = ::fidl::test::union_::StrictSimpleXUnion; |
| using StrictFoo = ::fidl::test::union_::StrictFoo; |
| using StrictBoundedXUnion = ::fidl::test::union_::StrictBoundedXUnion; |
| using ReverseOrdinalUnion = ::fidl::test::union_::ReverseOrdinalUnion; |
| using Pizza = ::fidl::test::union_::Pizza; |
| using Pasta = ::fidl::test::union_::Pasta; |
| using StrictPizzaOrPasta = ::fidl::test::union_::StrictPizzaOrPasta; |
| using PizzaOrPasta = ::fidl::test::union_::PizzaOrPasta; |
| using FlexiblePizzaOrPasta = ::fidl::test::union_::FlexiblePizzaOrPasta; |
| using ExplicitPizzaOrPasta = ::fidl::test::union_::ExplicitPizzaOrPasta; |
| using OlderSimpleUnion = ::fidl::test::union_::OlderSimpleUnion; |
| using NullableUnionStruct = ::fidl::test::union_::NullableUnionStruct; |
| using NewerSimpleUnion = ::fidl::test::union_::NewerSimpleUnion; |
| using FlexibleUnion = ::fidl::test::union_::FlexibleUnion; |
| using FlexibleFoo = ::fidl::test::union_::FlexibleFoo; |
| using FieldCollision = ::fidl::test::union_::FieldCollision; |
| using ExplicitXUnion = ::fidl::test::union_::ExplicitXUnion; |
| using ExplicitUnion = ::fidl::test::union_::ExplicitUnion; |
| using ExplicitStrictFoo = ::fidl::test::union_::ExplicitStrictFoo; |
| using ExplicitFoo = ::fidl::test::union_::ExplicitFoo; |
| using Empty = ::fidl::test::union_::Empty; |
| using XUnionContainingEmptyStruct = |
| ::fidl::test::union_::XUnionContainingEmptyStruct; |
| |
| template <> |
| struct MinSize<Union> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>(), MinSize<::std::string>(), |
| MinSize<::std::vector<::std::string>>()}; |
| return 1 + *std::max_element(sizes, sizes + 3 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<Union> { |
| static_assert(3 > 0, "xunion must have at least one member"); |
| |
| Union operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<Union>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| Union out; |
| switch (selector % 3) { |
| case 0: { |
| out.set_Primitive(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_StringNeedsConstructor(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 2: { |
| out.set_VectorStringAlsoNeedsConstructor( |
| Allocate<::std::vector<::std::string>>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StructWithNullableXUnion> { |
| operator size_t() { |
| return MinSize<::std::unique_ptr<::fidl::test::union_::OlderSimpleUnion>>(); |
| } |
| }; |
| template <> |
| struct Allocate<StructWithNullableXUnion> { |
| StructWithNullableXUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<StructWithNullableXUnion>()); |
| StructWithNullableXUnion out; |
| const size_t slack_per_member = |
| (*size - MinSize<StructWithNullableXUnion>()) / 1; |
| size_t out_size; |
| out_size = |
| MinSize<::std::unique_ptr<::fidl::test::union_::OlderSimpleUnion>>() + |
| slack_per_member; |
| out.x1 = |
| Allocate<::std::unique_ptr<::fidl::test::union_::OlderSimpleUnion>>{}( |
| src, &out_size); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StrictUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>(), MinSize<::std::string>(), |
| MinSize<::std::vector<::std::string>>()}; |
| return 1 + *std::max_element(sizes, sizes + 3 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<StrictUnion> { |
| static_assert(3 > 0, "xunion must have at least one member"); |
| |
| StrictUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<StrictUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| StrictUnion out; |
| switch (selector % 3) { |
| case 0: { |
| out.set_Primitive(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_StringNeedsConstructor(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 2: { |
| out.set_VectorStringAlsoNeedsConstructor( |
| Allocate<::std::vector<::std::string>>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StrictSimpleXUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>(), MinSize<float>(), |
| MinSize<::std::string>()}; |
| return 1 + *std::max_element(sizes, sizes + 3 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<StrictSimpleXUnion> { |
| static_assert(3 > 0, "xunion must have at least one member"); |
| |
| StrictSimpleXUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<StrictSimpleXUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| StrictSimpleXUnion out; |
| switch (selector % 3) { |
| case 0: { |
| out.set_i(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_f(Allocate<float>{}(src, size)); |
| break; |
| } |
| case 2: { |
| out.set_s(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StrictFoo> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::std::string>(), MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<StrictFoo> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| StrictFoo operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<StrictFoo>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| StrictFoo out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_s(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_i(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StrictBoundedXUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::std::vector<uint8_t>>()}; |
| return 1 + *std::max_element(sizes, sizes + 1 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<StrictBoundedXUnion> { |
| static_assert(1 > 0, "xunion must have at least one member"); |
| |
| StrictBoundedXUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<StrictBoundedXUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| StrictBoundedXUnion out; |
| switch (selector % 1) { |
| case 0: { |
| out.set_v(Allocate<::std::vector<uint8_t>>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<ReverseOrdinalUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<uint32_t>(), MinSize<uint32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<ReverseOrdinalUnion> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| ReverseOrdinalUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<ReverseOrdinalUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| ReverseOrdinalUnion out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_second(Allocate<uint32_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_first(Allocate<uint32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<Pizza> { |
| operator size_t() { return MinSize<::std::vector<::std::string>>(); } |
| }; |
| template <> |
| struct Allocate<Pizza> { |
| Pizza operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<Pizza>()); |
| Pizza out; |
| const size_t slack_per_member = (*size - MinSize<Pizza>()) / 1; |
| size_t out_size; |
| out_size = MinSize<::std::vector<::std::string>>() + slack_per_member; |
| out.toppings = Allocate<::std::vector<::std::string>>{}(src, &out_size); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<Pasta> { |
| operator size_t() { return MinSize<::std::string>(); } |
| }; |
| template <> |
| struct Allocate<Pasta> { |
| Pasta operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<Pasta>()); |
| Pasta out; |
| const size_t slack_per_member = (*size - MinSize<Pasta>()) / 1; |
| size_t out_size; |
| out_size = MinSize<::std::string>() + slack_per_member; |
| out.sauce = Allocate<::std::string>{}(src, &out_size); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StrictPizzaOrPasta> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::fidl::test::union_::Pizza>(), |
| MinSize<::fidl::test::union_::Pasta>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<StrictPizzaOrPasta> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| StrictPizzaOrPasta operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<StrictPizzaOrPasta>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| StrictPizzaOrPasta out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_pizza(Allocate<::fidl::test::union_::Pizza>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_pasta(Allocate<::fidl::test::union_::Pasta>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<PizzaOrPasta> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::fidl::test::union_::Pizza>(), |
| MinSize<::fidl::test::union_::Pasta>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<PizzaOrPasta> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| PizzaOrPasta operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<PizzaOrPasta>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| PizzaOrPasta out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_pizza(Allocate<::fidl::test::union_::Pizza>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_pasta(Allocate<::fidl::test::union_::Pasta>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<FlexiblePizzaOrPasta> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::fidl::test::union_::Pizza>(), |
| MinSize<::fidl::test::union_::Pasta>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<FlexiblePizzaOrPasta> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| FlexiblePizzaOrPasta operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<FlexiblePizzaOrPasta>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| FlexiblePizzaOrPasta out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_pizza(Allocate<::fidl::test::union_::Pizza>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_pasta(Allocate<::fidl::test::union_::Pasta>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<ExplicitPizzaOrPasta> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::fidl::test::union_::Pizza>(), |
| MinSize<::fidl::test::union_::Pasta>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<ExplicitPizzaOrPasta> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| ExplicitPizzaOrPasta operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<ExplicitPizzaOrPasta>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| ExplicitPizzaOrPasta out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_pizza(Allocate<::fidl::test::union_::Pizza>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_pasta(Allocate<::fidl::test::union_::Pasta>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<OlderSimpleUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int64_t>(), MinSize<float>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<OlderSimpleUnion> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| OlderSimpleUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<OlderSimpleUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| OlderSimpleUnion out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_i(Allocate<int64_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_f(Allocate<float>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<NullableUnionStruct> { |
| operator size_t() { |
| return MinSize<::std::unique_ptr<::fidl::test::union_::Union>>(); |
| } |
| }; |
| template <> |
| struct Allocate<NullableUnionStruct> { |
| NullableUnionStruct operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<NullableUnionStruct>()); |
| NullableUnionStruct out; |
| const size_t slack_per_member = |
| (*size - MinSize<NullableUnionStruct>()) / 1; |
| size_t out_size; |
| out_size = MinSize<::std::unique_ptr<::fidl::test::union_::Union>>() + |
| slack_per_member; |
| out.the_union = Allocate<::std::unique_ptr<::fidl::test::union_::Union>>{}( |
| src, &out_size); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<NewerSimpleUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int64_t>(), MinSize<::std::string>(), |
| MinSize<::std::vector<::std::string>>()}; |
| return 1 + *std::max_element(sizes, sizes + 3 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<NewerSimpleUnion> { |
| static_assert(3 > 0, "xunion must have at least one member"); |
| |
| NewerSimpleUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<NewerSimpleUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| NewerSimpleUnion out; |
| switch (selector % 3) { |
| case 0: { |
| out.set_i(Allocate<int64_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_s(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 2: { |
| out.set_v(Allocate<::std::vector<::std::string>>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<FlexibleUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>(), MinSize<::std::string>(), |
| MinSize<::std::vector<::std::string>>()}; |
| return 1 + *std::max_element(sizes, sizes + 3 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<FlexibleUnion> { |
| static_assert(3 > 0, "xunion must have at least one member"); |
| |
| FlexibleUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<FlexibleUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| FlexibleUnion out; |
| switch (selector % 3) { |
| case 0: { |
| out.set_Primitive(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_StringNeedsConstructor(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 2: { |
| out.set_VectorStringAlsoNeedsConstructor( |
| Allocate<::std::vector<::std::string>>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<FlexibleFoo> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::std::string>(), MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<FlexibleFoo> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| FlexibleFoo operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<FlexibleFoo>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| FlexibleFoo out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_s(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_i(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<FieldCollision> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 1 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<FieldCollision> { |
| static_assert(1 > 0, "xunion must have at least one member"); |
| |
| FieldCollision operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<FieldCollision>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| FieldCollision out; |
| switch (selector % 1) { |
| case 0: { |
| out.set_field_collision_tag(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<ExplicitXUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int64_t>(), MinSize<float>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<ExplicitXUnion> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| ExplicitXUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<ExplicitXUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| ExplicitXUnion out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_i(Allocate<int64_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_f(Allocate<float>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<ExplicitUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>(), MinSize<::std::string>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<ExplicitUnion> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| ExplicitUnion operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<ExplicitUnion>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| ExplicitUnion out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_Primitive(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_StringNeedsConstructor(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<ExplicitStrictFoo> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::std::string>(), MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<ExplicitStrictFoo> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| ExplicitStrictFoo operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<ExplicitStrictFoo>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| ExplicitStrictFoo out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_s(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_i(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<ExplicitFoo> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::std::string>(), MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 2 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<ExplicitFoo> { |
| static_assert(2 > 0, "xunion must have at least one member"); |
| |
| ExplicitFoo operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<ExplicitFoo>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| ExplicitFoo out; |
| switch (selector % 2) { |
| case 0: { |
| out.set_s(Allocate<::std::string>{}(src, size)); |
| break; |
| } |
| case 1: { |
| out.set_i(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<Empty> { |
| operator size_t() { return MinSize<uint8_t>(); } |
| }; |
| template <> |
| struct Allocate<Empty> { |
| Empty operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<Empty>()); |
| Empty out; |
| const size_t slack_per_member = (*size - MinSize<Empty>()) / 1; |
| size_t out_size; |
| out_size = MinSize<uint8_t>() + slack_per_member; |
| out.__reserved = Allocate<uint8_t>{}(src, &out_size); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<XUnionContainingEmptyStruct> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<::fidl::test::union_::Empty>()}; |
| return 1 + *std::max_element(sizes, sizes + 1 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<XUnionContainingEmptyStruct> { |
| static_assert(1 > 0, "xunion must have at least one member"); |
| |
| XUnionContainingEmptyStruct operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<XUnionContainingEmptyStruct>()); |
| |
| uint8_t selector; |
| ZX_ASSERT(src->CopyBytes(&selector, 1)); |
| (*size)++; |
| |
| XUnionContainingEmptyStruct out; |
| switch (selector % 1) { |
| case 0: { |
| out.set_empty(Allocate<::fidl::test::union_::Empty>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| |
| } // namespace fuzzing |