go test -fuzz=FuzzDeadline -timeout=0 -fuzztime=1s -wantdeadline=false
go test -fuzz=FuzzDeadline -timeout=0 -fuzztime=100x -wantdeadline=false

-- go.mod --
module fuzz

go 1.16
-- fuzz_deadline_test.go --
package fuzz_test

import (
	"flag"
	"testing"
)

var wantDeadline = flag.Bool("wantdeadline", false, "whether the test should have a deadline")

func FuzzDeadline(f *testing.F) {
	f.Add("run once")

	}
}

// checkFuzzCall checks the arguments of f.Fuzz() calls:
//
//  1. f.Fuzz() should call a function and it should be of type (*testing.F).Fuzz().
//  2. The called function in f.Fuzz(func(){}) should not return result.
//  3. First argument of func() should be of type *testing.T
//  4. Second argument onwards should be of type []byte, string, bool, byte,
//     rune, float32, float64, int, int8, int16, int32, int64, uint, uint8, uint16,

[short] skip
[!fuzz-instrumented] skip

env GOCACHE=$WORK/gocache
go test -fuzz=FuzzCovMin -fuzztime=500000x -test.fuzzcachedir=$GOCACHE/fuzz
go run check_file/main.go $GOCACHE/fuzz/FuzzCovMin ab

-- go.mod --
module test

-- covmin_test.go --
package covmin

import "testing"

func FuzzCovMin(f *testing.F) {
	f.Add([]byte("aa"))
	f.Fuzz(func(t *testing.T, data []byte) {

// limitations under the License.

package ca

import (
	"testing"
	"time"

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

func FuzzIstioCASign(f *testing.F) {
	f.Fuzz(func(t *testing.T, data, csrPEM []byte) {
		ff := fuzz.NewConsumer(data)
		// create ca options
		opts := &IstioCAOptions{}
		err := ff.GenerateStruct(opts)
		if err != nil {
			return
		}

// limitations under the License.

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
		}

package webhook

import (
	"math/rand"
	"reflect"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	fuzz "github.com/google/gofuzz"

	authenticationv1 "k8s.io/api/authentication/v1"
	authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
)

func TestRoundTrip(t *testing.T) {
	f := fuzz.New()
	seed := time.Now().UnixNano()
	t.Logf("seed = %v", seed)
	f.RandSource(rand.New(rand.NewSource(seed)))

	metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1"

	"github.com/google/go-cmp/cmp"
	fuzz "github.com/google/gofuzz"
)

func TestAsPartialObjectMetadata(t *testing.T) {
	f := fuzz.New().NilChance(.5).NumElements(0, 1).RandSource(rand.NewSource(1))

	for i := 0; i < 100; i++ {
		m := &metav1.ObjectMeta{}
		f.Fuzz(m)
		partial := AsPartialObjectMetadata(m)
		if !reflect.DeepEqual(&partial.ObjectMeta, m) {

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package fuzz

import (
	fuzz "github.com/AdaLogics/go-fuzz-headers"
	corev1 "k8s.io/api/core/v1"
	knetworking "k8s.io/api/networking/v1"
	"k8s.io/apimachinery/pkg/runtime"

	meshconfig "istio.io/api/mesh/v1alpha1"

// limitations under the License.

package ra

import (
	"testing"

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

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

		// create subjectIDs
		subjectIDs := make([]string, 0)
		noOfEntries, err := ff.GetUint64()
		if err != nil {

	defer cancel()
	err := fuzz.RunFuzzWorker(ctx, fn)
	if err == ctx.Err() {
		return nil
	}
	return err
}

func (TestDeps) ReadCorpus(dir string, types []reflect.Type) ([]fuzz.CorpusEntry, error) {
	return fuzz.ReadCorpus(dir, types)
}

func (TestDeps) CheckCorpus(vals []any, types []reflect.Type) error {
	return fuzz.CheckCorpus(vals, types)
}