t.Errorf("FieldIgnore should not be created")
	}

	if DB.Migrator().HasColumn(&CustomizeFieldStruct{}, "field_ignore") {
		t.Errorf("FieldIgnore should not be created")
	}

	generateStruct := func(name string) *CustomizeFieldStruct {
		return &CustomizeFieldStruct{
			Name:             name,
			FieldAllowCreate: name + "_allow_create",
			FieldAllowUpdate: name + "_allow_update",

// Additionally, if the T implements Validator, it will implicitly be used.
func Struct[T any](h Helper, validators ...func(T) bool) T {
	d := new(T)
	if err := h.cf.GenerateStruct(d); err != nil {
		h.t.Skip(err.Error())
	}
	r := *d
	validate(h, validators, r)
	return r
}

// Slice generates a slice of Structs
func Slice[T any](h Helper, count int, validators ...func(T) bool) []T {

)

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

		// create injection parameters
		IP := InjectionParameters{}
		err := ff.GenerateStruct(&IP)
		if err != nil {
			return
		}
		if IP.pod == nil {
			return
		}
		vc, err := NewValuesConfig(v)
		if err != nil {
			return
		}
		IP.valuesConfig = vc

		// call RunTemplate()

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

		return 0
	}
	certChainPem, err := f.GetBytes()
	if err != nil {
		return 0
	}
	rootCertPem, err := f.GetBytes()
	if err != nil {
		return 0
	}
	expectedFields := &util.VerifyFields{}
	err = f.GenerateStruct(expectedFields)
	if err != nil {
		return 0
	}
	util.VerifyCertificate(privPem, certChainPem, rootCertPem, expectedFields)
	return 1
}

// FindRootCertFromCertificateChainBytesFuzz implements a fuzzer

	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)

)

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

		i := New(cfg)

		// create template file

	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
	}

// 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
	}

	// Convert the obj and report if it fails.

		return 0
	}

	// Create kube config file
	kubeConfigFile, err := createRandomConfigFile(f)
	if err != nil {
		return 0
	}
	defer os.Remove(kubeConfigFile)

	args := &bootstrap.PilotArgs{}
	err = f.GenerateStruct(args)
	if err != nil {
		return 0
	}

	args.MeshConfigFile = meshConfigFile
	args.RegistryOptions.KubeConfig = kubeConfigFile
	args.ShutdownDuration = 1 * time.Millisecond

	stop := make(chan struct{})