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

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

// fidl_experiment = output_index_json

#pragma once

#include <test/unionsandwich/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 UnionSize8Alignment4 = ::test::unionsandwich::UnionSize8Alignment4;
using SandwichUnionSize8Alignment4 = ::test::unionsandwich::SandwichUnionSize8Alignment4;
using UnionSize12Alignment4 = ::test::unionsandwich::UnionSize12Alignment4;
using SandwichUnionSize12Alignment4 = ::test::unionsandwich::SandwichUnionSize12Alignment4;
using StructSize16Alignment8 = ::test::unionsandwich::StructSize16Alignment8;
using UnionSize24Alignment8 = ::test::unionsandwich::UnionSize24Alignment8;
using SandwichUnionSize24Alignment8 = ::test::unionsandwich::SandwichUnionSize24Alignment8;
using UnionSize36Alignment4 = ::test::unionsandwich::UnionSize36Alignment4;
using SandwichUnionSize36Alignment4 = ::test::unionsandwich::SandwichUnionSize36Alignment4;

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

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

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

    UnionSize8Alignment4 out;
    switch (selector % 1) {
      case 0: {
        out.set_variant(Allocate<uint32_t>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<SandwichUnionSize8Alignment4> {
  operator size_t() {
    return MinSize<uint32_t>() + MinSize<::test::unionsandwich::UnionSize8Alignment4>() + MinSize<uint32_t>();
  }
};
template <>
struct Allocate<SandwichUnionSize8Alignment4> {
  SandwichUnionSize8Alignment4 operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<SandwichUnionSize8Alignment4>());
    SandwichUnionSize8Alignment4 out;
    const size_t slack_per_member = (*size - MinSize<SandwichUnionSize8Alignment4>()) / 3;
    size_t out_size;
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.before = Allocate<uint32_t>{}(src, &out_size);
    out_size = MinSize<::test::unionsandwich::UnionSize8Alignment4>() + slack_per_member;
    out.union_ = Allocate<::test::unionsandwich::UnionSize8Alignment4>{}(src, &out_size);
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.after = Allocate<uint32_t>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<UnionSize12Alignment4> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<::std::array<uint8_t, 6>>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<UnionSize12Alignment4> {
  static_assert(1 > 0, "xunion must have at least one member");

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

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

    UnionSize12Alignment4 out;
    switch (selector % 1) {
      case 0: {
        out.set_variant(Allocate<::std::array<uint8_t, 6>>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<SandwichUnionSize12Alignment4> {
  operator size_t() {
    return MinSize<uint32_t>() + MinSize<::test::unionsandwich::UnionSize12Alignment4>() + MinSize<int32_t>();
  }
};
template <>
struct Allocate<SandwichUnionSize12Alignment4> {
  SandwichUnionSize12Alignment4 operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<SandwichUnionSize12Alignment4>());
    SandwichUnionSize12Alignment4 out;
    const size_t slack_per_member = (*size - MinSize<SandwichUnionSize12Alignment4>()) / 3;
    size_t out_size;
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.before = Allocate<uint32_t>{}(src, &out_size);
    out_size = MinSize<::test::unionsandwich::UnionSize12Alignment4>() + slack_per_member;
    out.union_ = Allocate<::test::unionsandwich::UnionSize12Alignment4>{}(src, &out_size);
    out_size = MinSize<int32_t>() + slack_per_member;
    out.after = Allocate<int32_t>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<StructSize16Alignment8> {
  operator size_t() {
    return MinSize<uint64_t>() + MinSize<uint64_t>();
  }
};
template <>
struct Allocate<StructSize16Alignment8> {
  StructSize16Alignment8 operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<StructSize16Alignment8>());
    StructSize16Alignment8 out;
    const size_t slack_per_member = (*size - MinSize<StructSize16Alignment8>()) / 2;
    size_t out_size;
    out_size = MinSize<uint64_t>() + slack_per_member;
    out.f1 = Allocate<uint64_t>{}(src, &out_size);
    out_size = MinSize<uint64_t>() + slack_per_member;
    out.f2 = Allocate<uint64_t>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<UnionSize24Alignment8> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<::test::unionsandwich::StructSize16Alignment8>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<UnionSize24Alignment8> {
  static_assert(1 > 0, "xunion must have at least one member");

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

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

    UnionSize24Alignment8 out;
    switch (selector % 1) {
      case 0: {
        out.set_variant(Allocate<::test::unionsandwich::StructSize16Alignment8>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<SandwichUnionSize24Alignment8> {
  operator size_t() {
    return MinSize<uint32_t>() + MinSize<::test::unionsandwich::UnionSize24Alignment8>() + MinSize<uint32_t>();
  }
};
template <>
struct Allocate<SandwichUnionSize24Alignment8> {
  SandwichUnionSize24Alignment8 operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<SandwichUnionSize24Alignment8>());
    SandwichUnionSize24Alignment8 out;
    const size_t slack_per_member = (*size - MinSize<SandwichUnionSize24Alignment8>()) / 3;
    size_t out_size;
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.before = Allocate<uint32_t>{}(src, &out_size);
    out_size = MinSize<::test::unionsandwich::UnionSize24Alignment8>() + slack_per_member;
    out.union_ = Allocate<::test::unionsandwich::UnionSize24Alignment8>{}(src, &out_size);
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.after = Allocate<uint32_t>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<UnionSize36Alignment4> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<::std::array<uint8_t, 32>>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<UnionSize36Alignment4> {
  static_assert(1 > 0, "xunion must have at least one member");

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

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

    UnionSize36Alignment4 out;
    switch (selector % 1) {
      case 0: {
        out.set_variant(Allocate<::std::array<uint8_t, 32>>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<SandwichUnionSize36Alignment4> {
  operator size_t() {
    return MinSize<uint32_t>() + MinSize<::test::unionsandwich::UnionSize36Alignment4>() + MinSize<uint32_t>();
  }
};
template <>
struct Allocate<SandwichUnionSize36Alignment4> {
  SandwichUnionSize36Alignment4 operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<SandwichUnionSize36Alignment4>());
    SandwichUnionSize36Alignment4 out;
    const size_t slack_per_member = (*size - MinSize<SandwichUnionSize36Alignment4>()) / 3;
    size_t out_size;
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.before = Allocate<uint32_t>{}(src, &out_size);
    out_size = MinSize<::test::unionsandwich::UnionSize36Alignment4>() + slack_per_member;
    out.union_ = Allocate<::test::unionsandwich::UnionSize36Alignment4>{}(src, &out_size);
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.after = Allocate<uint32_t>{}(src, &out_size);
    return out;
  }
};

}  // namespace fuzzing