err = f.GenerateStruct(in)
		if err != nil {
			return 0
		}
		c.Spec = in
		_, _ = validation.ValidateSidecar(c)
	case 4:
		in := &security_beta.AuthorizationPolicy{}
		err = f.GenerateStruct(in)
		if err != nil {
			return 0
		}
		c.Spec = in
		_, _ = validation.ValidateAuthorizationPolicy(c)
	case 5:
		in := &security_beta.RequestAuthentication{}
		err = f.GenerateStruct(in)
		if err != nil {

			return
		}

		loadAssignment := &endpoint.ClusterLoadAssignment{}
		err = ff.GenerateStruct(loadAssignment)
		if err != nil {
			return
		}

		locality := &core.Locality{}
		err = ff.GenerateStruct(locality)
		if err != nil {
			return
		}

		localityLB := &v1alpha3.LocalityLoadBalancerSetting{}
		err = ff.GenerateStruct(localityLB)
		if err != nil {
			return
		}

		enableFailover, err := ff.GetBool()

}

func FuzzValidateClusters(data []byte) int {
	proxy := model.Proxy{}
	f := fuzz.NewConsumer(data)
	to := core.TestOptions{}
	err := f.GenerateStruct(&to)
	if err != nil {
		return 0
	}
	err = ValidateTestOptions(to)
	if err != nil {
		return 0
	}
	err = f.GenerateStruct(&proxy)
	if err != nil || !proxy.FuzzValidate() {
		return 0
	}
	cg := core.NewConfigGenTest(utils.NopTester{}, to)
	p := cg.SetupProxy(&proxy)

func FuzzAggregateController(data []byte) int {
	ops := map[int]string{
		0: "AddRegistry",
		1: "DeleteRegistry",
	}
	maxOps := 2
	f := fuzz.NewConsumer(data)
	opts := aggregate.Options{}
	err := f.GenerateStruct(&opts)
	if err != nil {
		return 0
	}
	opts.MeshHolder = meshHolder
	c := aggregate.NewController(opts)

	iterations, err := f.GetInt()
	if err != nil {
		return 0
	}

	"istio.io/istio/security/pkg/server/ca"
	"istio.io/istio/security/pkg/server/ca/authenticate"
)

func FuzzGenCSR(data []byte) int {
	f := fuzz.NewConsumer(data)
	certOptions := util.CertOptions{}
	err := f.GenerateStruct(&certOptions)
	if err != nil {
		return 0
	}
	_, _, _ = util.GenCSR(certOptions)
	return 1
}

func fuzzedCertChain(f *fuzz.ConsumeFuzzer) ([][]*x509.Certificate, error) {

// The fuzzer then uses the controller to test:
// 1: OnConnect
// 2: OnDisconnect
// 3: QueueWorkloadEntryHealth
func FuzzWE(data []byte) int {
	f := fuzz.NewConsumer(data)
	proxy := &model.Proxy{}
	err := f.GenerateStruct(proxy)
	if err != nil {
		return 0
	}
	if !proxy.FuzzValidate() {
		return 0
	}

	store := memory.NewController(memory.Make(collections.All))

	protocol.Mongo,
	protocol.Redis,
	protocol.MySQL,
}

// Creates a new fuzzed ServiceInstance
func NewSI(f *fuzz.ConsumeFuzzer) (*model.ServiceInstance, error) {
	si := &model.ServiceInstance{}
	err := f.GenerateStruct(si)
	if err != nil {
		return si, err
	}
	s, err := NewS(f)
	if err != nil {
		return si, err
	}
	p, err := createPort(f)
	if err != nil {
		return si, err
	}
	s.Ports = append(s.Ports, p)

	k8sobjBytes, err := f.GetBytes()
	if err != nil {
		return 0
	}
	k8obj, err := object.ParseYAMLToK8sObject(k8sobjBytes)
	if err != nil {
		return 0
	}
	m := name.Manifest{}
	err = f.GenerateStruct(&m)
	if err != nil {
		return 0
	}
	obj := k8obj.UnstructuredObject()
	gvk := obj.GetObjectKind().GroupVersionKind()
	if len(gvk.Kind) == 0 {
		return 0
	}
	if len(gvk.Version) == 0 {
		return 0
	}