// The messages are not helpful since either the user triggered the error
			// (with ^C) or another more helpful message will be printed (a crasher).
			err = nil
		}
		if err != nil && (fuzzErr == nil || fuzzErr == ctx.Err()) {
			fuzzErr = err
		}
		if stopping {
			return
		}
		stopping = true
		cancelWorkers()
		doneC = nil
	}

	// Ensure that any crash we find is written to the corpus, even if an error

}

func TestValidateNestedValueValidationComplete(t *testing.T) {
	fuzzer := fuzz.New()
	fuzzer.Funcs(
		func(s *JSON, c fuzz.Continue) {
			if c.RandBool() {
				s.Object = float64(42.0)
			}
		},
		func(s **NestedValueValidation, c fuzz.Continue) {
			if c.RandBool() {
				*s = &NestedValueValidation{}
			}
		},
	)
	fuzzer.NilChance(0)

	cancel := make(chan struct{})
	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)]

package install

import (
	"testing"

	"k8s.io/apimachinery/pkg/api/apitesting/roundtrip"
	"k8s.io/kubernetes/pkg/apis/apiserverinternal/fuzzer"
)

func TestRoundTrip(t *testing.T) {
	roundtrip.RoundTripTestForAPIGroup(t, Install, fuzzer.Funcs)
	roundtrip.RoundTripProtobufTestForAPIGroup(t, Install, fuzzer.Funcs)

					},
				},
			},
		},
	}

	// Add some fuzzed RCs.
	apiObjectFuzzer := fuzzer.FuzzerFor(fuzzer.MergeFuzzerFuncs(metafuzzer.Funcs, corefuzzer.Funcs), rand.NewSource(152), legacyscheme.Codecs)
	for i := 0; i < 100; i++ {
		rc := &v1.ReplicationController{}
		apiObjectFuzzer.Fuzz(rc)
		// Sometimes the fuzzer decides to leave Spec.Template nil.

package install

import (
	"testing"

	"k8s.io/apimachinery/pkg/api/apitesting/roundtrip"
	"k8s.io/apiserver/pkg/apis/audit/fuzzer"
)

func TestRoundTrip(t *testing.T) {
	roundtrip.RoundTripTestForAPIGroup(t, Install, fuzzer.Funcs)
	roundtrip.RoundTripProtobufTestForAPIGroup(t, Install, fuzzer.Funcs)

	codec := json.NewSerializer(json.DefaultMetaFactory, scheme, scheme, false)
	seed := rand.Int63()
	fuzzer := fuzzer.FuzzerFor(metafuzzer.Funcs, rand.NewSource(seed), codecs)

	N := 1000
	for i := 0; i < N; i++ {
		u := &unstructured.Unstructured{Object: map[string]interface{}{}}
		original := &metav1.ObjectMeta{}
		fuzzer.Fuzz(original)
		if err := SetObjectMeta(u.Object, original); err != nil {

	}
	_, _ = util.ExtractIDs(extensions)
	return 1
}

// FuzzPemCertBytestoString implements a fuzzer
// that tests PemCertBytestoString
func FuzzPemCertBytestoString(data []byte) int {
	_ = util.PemCertBytestoString(data)
	return 1
}

// FuzzParsePemEncodedCertificateChain implements
// a fuzzer that tests ParsePemEncodedCertificateChain
func FuzzParsePemEncodedCertificateChain(data []byte) int {

*/

package scheme

import (
	"testing"

	"k8s.io/apimachinery/pkg/api/apitesting/roundtrip"
	"k8s.io/kubernetes/pkg/controller/apis/config/fuzzer"
)

func TestRoundTripTypes(t *testing.T) {
	roundtrip.RoundTripTestForScheme(t, Scheme, fuzzer.Funcs)

	err = v2scheme.AddToScheme(scheme)
	require.NoError(t, err)
	err = v2scheme.RegisterConversions(scheme)
	require.NoError(t, err)

	fuzzer := fuzz.NewWithSeed(2374375)

	// v2 -> v2beta1 -> v2
	for i := 0; i < 100; i++ {
		expected := &v2.APIGroupDiscoveryList{}
		fuzzer.Fuzz(expected)
		expected.TypeMeta = metav1.TypeMeta{
			Kind:       "APIGroupDiscoveryList",
			APIVersion: "apidiscovery.k8s.io/v2",
		}