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

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

// fidl_experiment = output_index_json

#pragma once

#include <test/enum/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 MyStrictEnum = ::test::enum_::MyStrictEnum;
using MyFlexibleEnum = ::test::enum_::MyFlexibleEnum;
using MyFlexibleEnumWithCustomUnknown = ::test::enum_::MyFlexibleEnumWithCustomUnknown;
using MyEmptyFlexibleEnum = ::test::enum_::MyEmptyFlexibleEnum;

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<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<MyFlexibleEnumWithCustomUnknown> {
  operator size_t() { return sizeof(uint64_t); }
};
template <>
struct Allocate<MyFlexibleEnumWithCustomUnknown> {
  MyFlexibleEnumWithCustomUnknown operator()(FuzzInput* src, size_t* size) {
    MyFlexibleEnumWithCustomUnknown out;
    uint64_t selector;
    ZX_ASSERT(*size >= sizeof(uint64_t));
    ZX_ASSERT(src->CopyObject(&selector));
    *size = sizeof(uint64_t);

    switch (selector % 3) {
      case 0:
        out = MyFlexibleEnumWithCustomUnknown::FOO;
        break;
      case 1:
        out = MyFlexibleEnumWithCustomUnknown::BAR;
        break;
      case 2:
        out = MyFlexibleEnumWithCustomUnknown::CUSTOM_UNKNOWN;
        break;
    }

    return out;
  }
};
template <>
struct MinSize<MyEmptyFlexibleEnum> {
  operator size_t() { return sizeof(uint64_t); }
};
template <>
struct Allocate<MyEmptyFlexibleEnum> {
  MyEmptyFlexibleEnum operator()(FuzzInput* src, size_t* size) {
    MyEmptyFlexibleEnum out;
    uint64_t selector;
    ZX_ASSERT(*size >= sizeof(uint64_t));
    ZX_ASSERT(src->CopyObject(&selector));
    *size = sizeof(uint64_t);

    switch (selector % 0) {
    }

    return out;
  }
};

}  // namespace fuzzing