tools/fidl/fidlgen_libfuzzer/goldens/empty_struct.h.golden

// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = no_optional_structs
// fidl_experiment = output_index_json
// fidl_experiment = simple_empty_response_syntax
// fidl_experiment = unknown_interactions

#pragma once

#include <test/emptystruct/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 Empty = ::test::emptystruct::Empty;
using EmptyProtocolSendRequest = ::test::emptystruct::EmptyProtocolSendRequest;
using EmptyProtocolReceiveRequest = ::test::emptystruct::EmptyProtocolReceiveRequest;
using EmptyProtocolSendAndReceiveRequest = ::test::emptystruct::EmptyProtocolSendAndReceiveRequest;
using EmptyProtocolSendAndReceiveResponse = ::test::emptystruct::EmptyProtocolSendAndReceiveResponse;

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<EmptyProtocolSendRequest> {
  operator size_t() {
    return MinSize<::test::emptystruct::Empty>();
  }
};
template <>
struct Allocate<EmptyProtocolSendRequest> {
  EmptyProtocolSendRequest operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<EmptyProtocolSendRequest>());
    EmptyProtocolSendRequest out;
    const size_t slack_per_member = (*size - MinSize<EmptyProtocolSendRequest>()) / 1;
    size_t out_size;
    out_size = MinSize<::test::emptystruct::Empty>() + slack_per_member;
    out.e = Allocate<::test::emptystruct::Empty>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<EmptyProtocolReceiveRequest> {
  operator size_t() {
    return MinSize<::test::emptystruct::Empty>();
  }
};
template <>
struct Allocate<EmptyProtocolReceiveRequest> {
  EmptyProtocolReceiveRequest operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<EmptyProtocolReceiveRequest>());
    EmptyProtocolReceiveRequest out;
    const size_t slack_per_member = (*size - MinSize<EmptyProtocolReceiveRequest>()) / 1;
    size_t out_size;
    out_size = MinSize<::test::emptystruct::Empty>() + slack_per_member;
    out.e = Allocate<::test::emptystruct::Empty>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<EmptyProtocolSendAndReceiveRequest> {
  operator size_t() {
    return MinSize<::test::emptystruct::Empty>();
  }
};
template <>
struct Allocate<EmptyProtocolSendAndReceiveRequest> {
  EmptyProtocolSendAndReceiveRequest operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<EmptyProtocolSendAndReceiveRequest>());
    EmptyProtocolSendAndReceiveRequest out;
    const size_t slack_per_member = (*size - MinSize<EmptyProtocolSendAndReceiveRequest>()) / 1;
    size_t out_size;
    out_size = MinSize<::test::emptystruct::Empty>() + slack_per_member;
    out.e = Allocate<::test::emptystruct::Empty>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<EmptyProtocolSendAndReceiveResponse> {
  operator size_t() {
    return MinSize<::test::emptystruct::Empty>();
  }
};
template <>
struct Allocate<EmptyProtocolSendAndReceiveResponse> {
  EmptyProtocolSendAndReceiveResponse operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<EmptyProtocolSendAndReceiveResponse>());
    EmptyProtocolSendAndReceiveResponse out;
    const size_t slack_per_member = (*size - MinSize<EmptyProtocolSendAndReceiveResponse>()) / 1;
    size_t out_size;
    out_size = MinSize<::test::emptystruct::Empty>() + slack_per_member;
    out.e = Allocate<::test::emptystruct::Empty>{}(src, &out_size);
    return out;
  }
};

}  // namespace fuzzing