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

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

// fidl_experiment = output_index_json

#pragma once

#include <test/arrays/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 StructSmallArray = ::test::arrays::StructSmallArray;
using StructLargeArray = ::test::arrays::StructLargeArray;
using TableSmallArray = ::test::arrays::TableSmallArray;
using TableLargeArray = ::test::arrays::TableLargeArray;
using UnionSmallArray = ::test::arrays::UnionSmallArray;
using UnionLargeArray = ::test::arrays::UnionLargeArray;

template <>
struct MinSize<StructSmallArray> {
  operator size_t() {
    return MinSize<::std::array<uint32_t, 2>>();
  }
};
template <>
struct Allocate<StructSmallArray> {
  StructSmallArray operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<StructSmallArray>());
    StructSmallArray out;
    const size_t slack_per_member = (*size - MinSize<StructSmallArray>()) / 1;
    size_t out_size;
    out_size = MinSize<::std::array<uint32_t, 2>>() + slack_per_member;
    out.a = Allocate<::std::array<uint32_t, 2>>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<StructLargeArray> {
  operator size_t() {
    return MinSize<::std::array<uint32_t, 100>>();
  }
};
template <>
struct Allocate<StructLargeArray> {
  StructLargeArray operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<StructLargeArray>());
    StructLargeArray out;
    const size_t slack_per_member = (*size - MinSize<StructLargeArray>()) / 1;
    size_t out_size;
    out_size = MinSize<::std::array<uint32_t, 100>>() + slack_per_member;
    out.a = Allocate<::std::array<uint32_t, 100>>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<TableSmallArray> {
  operator size_t() {
    return MinSize<::std::array<uint32_t, 2>>();
  }
};
template <>
struct Allocate<TableSmallArray> {
  TableSmallArray operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<TableSmallArray>());
    TableSmallArray out;
    const size_t slack_per_member = (*size - MinSize<TableSmallArray>()) / 1;
    size_t out_size;
    out_size = MinSize<::std::array<uint32_t, 2>>() + slack_per_member;
    out.set_a(Allocate<::std::array<uint32_t, 2>>{}(src, &out_size));
    return out;
  }
};
template <>
struct MinSize<TableLargeArray> {
  operator size_t() {
    return MinSize<::std::array<uint32_t, 100>>();
  }
};
template <>
struct Allocate<TableLargeArray> {
  TableLargeArray operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<TableLargeArray>());
    TableLargeArray out;
    const size_t slack_per_member = (*size - MinSize<TableLargeArray>()) / 1;
    size_t out_size;
    out_size = MinSize<::std::array<uint32_t, 100>>() + slack_per_member;
    out.set_a(Allocate<::std::array<uint32_t, 100>>{}(src, &out_size));
    return out;
  }
};
template <>
struct MinSize<UnionSmallArray> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<::std::array<uint32_t, 2>>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<UnionSmallArray> {
  static_assert(1 > 0, "xunion must have at least one member");

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

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

    UnionSmallArray out;
    switch (selector % 1) {
      case 0: {
        out.set_a(Allocate<::std::array<uint32_t, 2>>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<UnionLargeArray> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<::std::array<uint32_t, 100>>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<UnionLargeArray> {
  static_assert(1 > 0, "xunion must have at least one member");

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

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

    UnionLargeArray out;
    switch (selector % 1) {
      case 0: {
        out.set_a(Allocate<::std::array<uint32_t, 100>>{}(src, size));
        break;
      }
    }

    return out;
  }
};

}  // namespace fuzzing