"istio.io/istio/security/pkg/pki/util"
	"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
}

	"istio.io/istio/pkg/config/validation"
	"istio.io/istio/pkg/config/validation/envoyfilter"
	"istio.io/istio/pkg/kube"
)

func FuzzConfigValidation(data []byte) int {
	f := fuzz.NewConsumer(data)
	configIndex, err := f.GetInt()
	if err != nil {
		return -1
	}

	r := collections.Pilot.All()[configIndex%len(collections.Pilot.All())]
	gvk := r.GroupVersionKind()
	kgvk := schema.GroupVersionKind{

	"istio.io/api/networking/v1alpha3"
)

func FuzzApplyLocalityLBSetting(f *testing.F) {
	f.Fuzz(func(t *testing.T, data []byte) {
		ff := fuzz.NewConsumer(data)
		proxyLabels := make(map[string]string)
		err := ff.FuzzMap(&proxyLabels)
		if err != nil {
			return
		}
		wrappedLocalityLbEndpoints := make([]*WrappedLocalityLbEndpoints, 0)

		if sr == nil {
			return errors.New("a ServiceRegistry was nil")
		}
	}
	return nil
}

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)

	"istio.io/istio/operator/pkg/name"
	"istio.io/istio/operator/pkg/object"
)

type fakeClientWrapper struct {
	client.Client
}

func FuzzHelmReconciler(data []byte) int {
	f := fuzz.NewConsumer(data)
	k8sobjBytes, err := f.GetBytes()
	if err != nil {
		return 0
	}
	k8obj, err := object.ParseYAMLToK8sObject(k8sobjBytes)
	if err != nil {
		return 0
	}
	m := name.Manifest{}

func FuzzHostMatcher(data []byte) int {
	k, v, err := getKandV(data)
	if err != nil {
		return 0
	}
	_ = matcher.HostMatcher(k, v)
	return 1
}

func FuzzMetadataListMatcher(data []byte) int {
	f := fuzz.NewConsumer(data)
	filter, err := f.GetString()
	if err != nil {
		return 0
	}
	number, err := f.GetInt()
	if err != nil {
		return 0
	}
	maxKeys := number % 100
	keys := make([]string, 0, maxKeys)

// registries and deleting them.
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()

// pseudo-random values.
// 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
	}

	if err != nil {
		return s, err
	}
	return s, nil
}

// Creates an Environment with fuzzed values
// and passes that to InitContext
func FuzzInitContext(data []byte) int {
	f := fuzz.NewConsumer(data)

	// Create service instances
	serviceInstances := make([]*model.ServiceInstance, 0, 20)
	number, err := f.GetInt()
	if err != nil {
		return 0
	}
	// We allow a maximum of 20 service instances