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

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

#pragma once

#include <test/errorsyntax/cpp/fidl.h>
#include <test/errorsyntax/parent/cpp/libfuzzer.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 ExampleUseOfErrorSyntax_CallWhichMayFail_Response = ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response;
using ExampleUseOfErrorSyntax_CallWhichMayFail_Result = ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result;
using ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse = ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse;
using ExampleUseOfErrorSyntaxCallWhichMayFailRequest = ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest;

template <>
struct MinSize<ExampleUseOfErrorSyntax_CallWhichMayFail_Response> {
  operator size_t() {
    return MinSize<int64_t>();
  }
};
template <>
struct Allocate<ExampleUseOfErrorSyntax_CallWhichMayFail_Response> {
  ExampleUseOfErrorSyntax_CallWhichMayFail_Response operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleUseOfErrorSyntax_CallWhichMayFail_Response>());
    ExampleUseOfErrorSyntax_CallWhichMayFail_Response out;
    const size_t slack_per_member = (*size - MinSize<ExampleUseOfErrorSyntax_CallWhichMayFail_Response>()) / 1;
    size_t out_size;
    out_size = MinSize<int64_t>() + slack_per_member;
    out.value = Allocate<int64_t>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<ExampleUseOfErrorSyntax_CallWhichMayFail_Result> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response>(), MinSize<uint32_t>()};
    return 1 + *std::max_element(sizes, sizes + 2 + 1);
  }
};
template <>
struct Allocate<ExampleUseOfErrorSyntax_CallWhichMayFail_Result> {
  static_assert(2 > 0, "xunion must have at least one member");

  ExampleUseOfErrorSyntax_CallWhichMayFail_Result operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleUseOfErrorSyntax_CallWhichMayFail_Result>());

    uint8_t selector;
    ZX_ASSERT(src->CopyBytes(&selector, 1));
    (*size)++;

    ExampleUseOfErrorSyntax_CallWhichMayFail_Result out;
    switch (selector % 2) {
      case 0: {
        out.set_response(Allocate<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response>{}(src, size));
        break;
      }
      case 1: {
        out.set_err(Allocate<uint32_t>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse> {
  operator size_t() {
    return MinSize<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>();
  }
};
template <>
struct Allocate<ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse> {
  ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse>());
    ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse out;
    const size_t slack_per_member = (*size - MinSize<ExampleUseOfErrorSyntaxCallWhichMayFailTopResponse>()) / 1;
    size_t out_size;
    out_size = MinSize<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>() + slack_per_member;
    out.result = Allocate<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<ExampleUseOfErrorSyntaxCallWhichMayFailRequest> {
  operator size_t() {
    return MinSize<::std::string>();
  }
};
template <>
struct Allocate<ExampleUseOfErrorSyntaxCallWhichMayFailRequest> {
  ExampleUseOfErrorSyntaxCallWhichMayFailRequest operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleUseOfErrorSyntaxCallWhichMayFailRequest>());
    ExampleUseOfErrorSyntaxCallWhichMayFailRequest out;
    const size_t slack_per_member = (*size - MinSize<ExampleUseOfErrorSyntaxCallWhichMayFailRequest>()) / 1;
    size_t out_size;
    out_size = MinSize<::std::string>() + slack_per_member;
    out.s = Allocate<::std::string>{}(src, &out_size);
    return out;
  }
};

}  // namespace fuzzing