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 {

	ispec := &v1alpha1.IstioOperatorSpec{}
	err := f.GenerateStruct(ispec)
	if err != nil {
		return 0
	}
	_ = validate.CheckIstioOperatorSpec(ispec, false)
	_ = validate.CheckIstioOperatorSpec(ispec, true)
	return 1
}

func FuzzV1Alpha1ValidateConfig(data []byte) int {
	f := fuzz.NewConsumer(data)

	iop := &v1alpha1.IstioOperatorSpec{}
	err := f.GenerateStruct(iop)
	if err != nil {
		return 0
	}

			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()

	f := fuzz.NewConsumer(data)

	proxy := &model.Proxy{}
	err := f.GenerateStruct(proxy)
	if err != nil {
		return 0
	}
	if !proxy.FuzzValidate() {
		return 0
	}

	w := &model.WatchedResource{}
	err = f.GenerateStruct(w)
	if err != nil {
		return 0
	}

	updates := &model.PushRequest{}
	err = f.GenerateStruct(updates)
	if err != nil {
		return 0
	}

		ff := fuzz.NewConsumer(data)
		// create ca options
		opts := &IstioCAOptions{}
		err := ff.GenerateStruct(opts)
		if err != nil {
			return
		}
		ca, err := NewIstioCA(opts)
		if err != nil {
			return
		}

		// create cert options
		certOpts := CertOpts{}
		err = ff.GenerateStruct(&certOpts)
		if err != nil {
			return
		}
		TTL, err := time.ParseDuration("800ms")
		if err != nil {

	return 1
}

func FuzzConvertIngressV1alpha3(data []byte) int {
	f := fuzz.NewConsumer(data)
	ing := knetworking.Ingress{}
	err := f.GenerateStruct(&ing)
	if err != nil {
		return 0
	}
	m := &meshconfig.MeshConfig{}
	err = f.GenerateStruct(m)
	if err != nil {
		return 0
	}
	ingress.ConvertIngressV1alpha3(ing, m, "mydomain")
	return 1
}

func FuzzReconcileStatuses(data []byte) int {
	f := fuzz.NewConsumer(data)
	current := &v1alpha1.IstioStatus{}
	err := f.GenerateStruct(current)
	if err != nil {
		return 0
	}
	desired := distribution.Progress{}
	err = f.GenerateStruct(&desired)
	if err != nil {
		return 0
	}
	_, _ = distribution.ReconcileStatuses(current, desired)
	return 1

}

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) {