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

package bootstrap

import (
	"bytes"
	"io"
	"os"
	"testing"

	fuzz "github.com/AdaLogics/go-fuzz-headers"
)

func FuzzWriteTo(f *testing.F) {
	f.Fuzz(func(t *testing.T, data []byte) {
		ff := fuzz.NewConsumer(data)

		// create config
		cfg := Config{}

		err := ff.GenerateStruct(&cfg)
		if err != nil {
			return
		}

		if cfg.Metadata == nil {
			return
		}
		if cfg.Metadata.ProxyConfig == nil {

import (
	"bytes"

	fuzz "github.com/AdaLogics/go-fuzz-headers"

	"istio.io/istio/pkg/config/mesh"
	"istio.io/istio/pkg/kube/inject"
)

func FuzzIntoResourceFile(data []byte) int {
	f := fuzz.NewConsumer(data)
	var sidecarTemplate map[string]string
	err := f.FuzzMap(&sidecarTemplate)
	if err != nil {
		return 0
	}
	valuesConfig, err := f.GetString()
	if err != nil {
		return 0
	}

	"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{}

// that has had pseudo-random values inserted.
// When a valid object has been created, it
// tries and convert that object. If this
// conversion fails, it panics.
func FuzzKubeCRD(data []byte) int {
	f := fuzz.NewConsumer(data)
	config := config2.Config{}
	err := f.GenerateStruct(&config)
	if err != nil {
		return 0
	}

	// Create a valid obj:
	obj, err := crd.ConvertConfig(config)
	if err != nil {
		return 0
	}

		if err != nil {
			return m, err
		}
		v, err := f.GetBytes()
		if err != nil {
			return m, err
		}
		m[k] = v
	}
	return m, nil
}

func FuzzCompareDiff(data []byte) int {
	f := fuzz.NewConsumer(data)
	istiodDumps, err := createIstiodDumps(f)
	if err != nil {
		return 0
	}
	envoyDump, err := f.GetBytes()
	if err != nil {
		return 0
	}
	var buf bytes.Buffer

import (
	"os"
	"time"

	fuzz "github.com/AdaLogics/go-fuzz-headers"

	"istio.io/istio/pilot/pkg/bootstrap"
	"istio.io/istio/pkg/config/mesh"
)

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

	// Create mesh config file
	meshConfigFile, err := createRandomConfigFile(f)
	if err != nil {
		return 0
	}
	defer os.Remove(meshConfigFile)
	_, err = os.Stat(meshConfigFile)
	if err != nil {

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