## Native fuzzers

While many jobs are still using the old [go-fuzz](https://github.com/dvyukov/go-fuzz) style fuzzers, using [Go 1.18 native fuzzing](https://go.dev/doc/fuzz/) is preferred.
These should be written alongside standard test packages.
Currently, these cannot be in `<pkg>_test` packages; instead move them to a file under `<pkg>`.

# functions called by testing or internal/fuzz in the background.

go test -c -fuzz=.  # Build using shared build cache for speed.
env GOCACHE=$WORK/gocache
exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinCache -test.fuzztime=1000x
go run check_cache/check_cache.go $GOCACHE/fuzz/FuzzMinCache

# Test that minimization occurs for a crash that appears while minimizing a

// limitations under the License.

package gateway

import (
	"testing"

	"istio.io/istio/pkg/fuzz"
)

func FuzzConvertResources(f *testing.F) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		r := fuzz.Struct[GatewayResources](fg)
		convertResources(r)
	})

stdout 'this is bad'

# Run skipped chatty fuzz targets.
go test -v chatty_skipped_fuzz_test.go
stdout ok
stdout SKIP
! stdout FAIL

# Run successful chatty fuzz targets.
go test -v chatty_fuzz_test.go
stdout ok
stdout PASS
stdout 'all good here'
! stdout FAIL

# Fuzz successful chatty fuzz target that includes a separate unit test.
go test -v chatty_with_test_fuzz_test.go -fuzz=Fuzz -fuzztime=1x
stdout ok
stdout PASS

	"testing"

	corev1 "k8s.io/api/core/v1"
	v1 "k8s.io/api/discovery/v1"

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pkg/fuzz"
	"istio.io/istio/pkg/network"
)

func FuzzKubeController(f *testing.F) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		networkID := network.ID("fakeNetwork")
		fco := fuzz.Struct[FakeControllerOptions](fg)
		fco.SkipRun = true
		// Overlapping CRDs would fail, just remove them
		fco.CRDs = nil

	return []interface{}{
		func(q *resource.Quantity, c fuzz.Continue) {
			*q = *resource.NewQuantity(c.Int63n(1000), resource.DecimalExponent)
		},
		func(j *int, c fuzz.Continue) {
			*j = int(c.Int31())
		},
		func(j **int, c fuzz.Continue) {
			if c.RandBool() {
				i := int(c.Int31())
				*j = &i
			} else {
				*j = nil
			}
		},
		func(j *runtime.TypeMeta, c fuzz.Continue) {

	return []interface{}{
		func(obj *admissionregistration.Rule, c fuzz.Continue) {
			c.FuzzNoCustom(obj) // fuzz self without calling this function again
			if obj.Scope == nil {
				s := admissionregistration.AllScopes
				obj.Scope = &s
			}
		},
		func(obj *admissionregistration.ValidatingWebhook, c fuzz.Continue) {
			c.FuzzNoCustom(obj) // fuzz self without calling this function again
			if obj.FailurePolicy == nil {

See the License for the specific language governing permissions and
limitations under the License.
*/

package v1

import (
	"time"

	fuzz "github.com/google/gofuzz"
)

// Fuzz satisfies fuzz.Interface.
func (t *Time) Fuzz(c fuzz.Continue) {
	if t == nil {
		return
	}
	// Allow for about 1000 years of randomness.  Leave off nanoseconds
	// because JSON doesn't represent them so they can't round-trip

go test -timeout=3s -fuzz=FuzzFast -fuzztime=5s

# We should see the same behavior when invoking the test binary directly.
go test -c
exec ./fuzz.test$GOEXE -test.timeout=3s -test.fuzz=FuzzFast -test.fuzztime=5s -test.parallel=1 -test.fuzzcachedir=$WORK/cache

# Timeout should not cause inputs to be written as crashers.
! exists testdata/fuzz

			}
		},
		func(j *apps.Deployment, c fuzz.Continue) {
			c.FuzzNoCustom(j)

			// match defaulting
			if j.Spec.Selector == nil {
				j.Spec.Selector = &metav1.LabelSelector{MatchLabels: j.Spec.Template.Labels}
			}
			if len(j.Labels) == 0 {
				j.Labels = j.Spec.Template.Labels
			}
		},
		func(j *apps.DeploymentSpec, c fuzz.Continue) {
			c.FuzzNoCustom(j) // fuzz self without calling this function again