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

				return
			}
		}
		panic(r)
	}
}

// New creates a new fuzz.Helper, capable of generating more complex types
func New(t test.Failer, data []byte) Helper {
	return Helper{cf: fuzzheaders.NewConsumer(data), t: t}
}

// Struct generates a Struct. Validation patterns can be passed in - if any return false, the fuzz case is skipped.
// Additionally, if the T implements Validator, it will implicitly be used.

	result, err := sa.Analyze(cancel)
	if err != nil {
		return local.AnalysisResult{}, err
	}
	return result, err
}

// FuzzAnalyzer implements the fuzzer
func FuzzAnalyzer(data []byte) int {
	f := fuzz.NewConsumer(data)
	analyzerIndex, err := f.GetInt()
	if err != nil {
		return 0
	}
	analyzer := availableAnalyzers[analyzerIndex%len(availableAnalyzers)]

	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

	}

	typeAcc, err := apimeta.TypeAccessor(object)
	if err != nil {
		panic(fmt.Sprintf("%q is not a TypeMeta and cannot be tested - add it to nonRoundTrippableInternalTypes: %v\n", kgvk, err))
	}
	f := fuzz.NewConsumer(data[1:])
	err = f.GenerateStruct(object)
	if err != nil {
		return 0
	}
	err = checkForNilValues(object)
	if err != nil {
		return 0
	}
	typeAcc.SetKind(kgvk.Kind)