| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include <fidl/test/doccomments/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 Table = ::fidl::test::doccomments::Table; |
| using Struct = ::fidl::test::doccomments::Struct; |
| using StrictUnion = ::fidl::test::doccomments::StrictUnion; |
| using Service = ::fidl::test::doccomments::Service; |
| using MyStrictEnum = ::fidl::test::doccomments::MyStrictEnum; |
| using MyStrictBits = ::fidl::test::doccomments::MyStrictBits; |
| using MyFlexibleEnum = ::fidl::test::doccomments::MyFlexibleEnum; |
| using MyFlexibleBits = ::fidl::test::doccomments::MyFlexibleBits; |
| using FlexibleUnion = ::fidl::test::doccomments::FlexibleUnion; |
| |
| template <> |
| struct MinSize<Table> { |
| operator size_t() { return MinSize<int32_t>(); } |
| }; |
| template <> |
| struct Allocate<Table> { |
| Table operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<Table>()); |
| Table out; |
| const size_t slack_per_member = (*size - MinSize<Table>()) / 1; |
| size_t out_size; |
| out_size = MinSize<int32_t>() + slack_per_member; |
| out.set_Field(Allocate<int32_t>{}(src, &out_size)); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<Struct> { |
| operator size_t() { return MinSize<int32_t>(); } |
| }; |
| template <> |
| struct Allocate<Struct> { |
| Struct operator()(FuzzInput* src, size_t* size) { |
| ZX_ASSERT(*size >= MinSize<Struct>()); |
| Struct out; |
| const size_t slack_per_member = (*size - MinSize<Struct>()) / 1; |
| size_t out_size; |
| out_size = MinSize<int32_t>() + slack_per_member; |
| out.Field = Allocate<int32_t>{}(src, &out_size); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<StrictUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 1 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<StrictUnion> { |
| static_assert(1 > 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 % 1) { |
| case 0: { |
| out.set_Field(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<MyStrictEnum> { |
| operator size_t() { return sizeof(uint64_t); } |
| }; |
| template <> |
| struct Allocate<MyStrictEnum> { |
| MyStrictEnum operator()(FuzzInput* src, size_t* size) { |
| MyStrictEnum out; |
| uint64_t selector; |
| ZX_ASSERT(*size >= sizeof(uint64_t)); |
| ZX_ASSERT(src->CopyObject(&selector)); |
| *size = sizeof(uint64_t); |
| |
| switch (selector % 2) { |
| case 0: |
| out = MyStrictEnum::FOO; |
| break; |
| case 1: |
| out = MyStrictEnum::BAR; |
| break; |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<MyStrictBits> { |
| operator size_t() { return sizeof(MyStrictBits); } |
| }; |
| template <> |
| struct Allocate<MyStrictBits> { |
| MyStrictBits operator()(FuzzInput* src, size_t* size) { |
| MyStrictBits out; |
| ZX_ASSERT(*size >= sizeof(MyStrictBits)); |
| ZX_ASSERT(src->CopyObject(&out)); |
| *size = sizeof(MyStrictBits); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<MyFlexibleEnum> { |
| operator size_t() { return sizeof(uint64_t); } |
| }; |
| template <> |
| struct Allocate<MyFlexibleEnum> { |
| MyFlexibleEnum operator()(FuzzInput* src, size_t* size) { |
| MyFlexibleEnum out; |
| uint64_t selector; |
| ZX_ASSERT(*size >= sizeof(uint64_t)); |
| ZX_ASSERT(src->CopyObject(&selector)); |
| *size = sizeof(uint64_t); |
| |
| switch (selector % 2) { |
| case 0: |
| out = MyFlexibleEnum::FOO; |
| break; |
| case 1: |
| out = MyFlexibleEnum::BAR; |
| break; |
| } |
| |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<MyFlexibleBits> { |
| operator size_t() { return sizeof(MyFlexibleBits); } |
| }; |
| template <> |
| struct Allocate<MyFlexibleBits> { |
| MyFlexibleBits operator()(FuzzInput* src, size_t* size) { |
| MyFlexibleBits out; |
| ZX_ASSERT(*size >= sizeof(MyFlexibleBits)); |
| ZX_ASSERT(src->CopyObject(&out)); |
| *size = sizeof(MyFlexibleBits); |
| return out; |
| } |
| }; |
| template <> |
| struct MinSize<FlexibleUnion> { |
| operator size_t() { |
| size_t sizes[] = {0, MinSize<int32_t>()}; |
| return 1 + *std::max_element(sizes, sizes + 1 + 1); |
| } |
| }; |
| template <> |
| struct Allocate<FlexibleUnion> { |
| static_assert(1 > 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 % 1) { |
| case 0: { |
| out.set_Field(Allocate<int32_t>{}(src, size)); |
| break; |
| } |
| } |
| |
| return out; |
| } |
| }; |
| |
| } // namespace fuzzing |