! stderr '(compile|gccgo)( |\.exe).*empty.go'

# Fuzzing indicates that one new interesting value was found with an empty
# corpus, and the total size of the cache is now 1.
go clean -fuzzcache
go test -fuzz=FuzzEmpty -fuzztime=10000x .
stdout 'new interesting: 1'
stdout 'total: 1'

# Fuzzing again with a small fuzztime does not find any other interesting
# values but still indicates that the cache size is 1.

// license that can be found in the LICENSE file.

package main

var G int

func main() {
	if G != 101 {
		println("not 101")
	} else {
		println("well now that's interesting")
	}

fuzz: elapsed: 0s, gathering baseline coverage: 390/390 completed, now fuzzing with 16 workers
fuzz: elapsed: 3s, execs: 438666 (146173/sec), new interesting: 12 (total: 402)
fuzz: elapsed: 4s, execs: 558467 (147850/sec), new interesting: 15 (total: 405)
--- PASS: FuzzParse (3.85s)
=== NAME

// value.
func byteSliceOverwriteInterestingUint8(m *mutator, b []byte) []byte {
	if len(b) == 0 {
		return nil
	}
	pos := m.rand(len(b))
	b[pos] = byte(interesting8[m.rand(len(interesting8))])
	return b
}

// byteSliceOverwriteInterestingUint16 overwrites a random uint16 in b with an interesting
// value.

			t.Errorf("EscapeString(%q) = %q, UnescapeString(%q) = %q, want %q", v, e, e, u, v)
		}

		// As per the documentation, this isn't always equal to v, so it makes
		// no sense to check for equality. It can still be interesting to find
		// panics in it though.
		EscapeString(UnescapeString(v))
	})

Most of these ideas would be more or less **independent**, and in most cases you should only need to study them if they apply directly to **your project**.

If something seems interesting and useful to your project, go ahead and check it, but otherwise, you might probably just skip them.

!!! tip

// compile

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// golang.org/issue/12686.
// interesting because it's a non-constant but ideal value
// and we used to incorrectly attach a constant Val to the Node.

package p

func f(i uint) uint {
	x := []uint{1 << i}
	return x[0]

[short] skip
[!fuzz-instrumented] skip

# Test that when an interesting value is discovered (one that expands coverage),
# the fuzzing engine minimizes it before writing it to the cache.
#
# The program below starts with a seed value of length 100, but more coverage
# will be found for any value other than the seed. We should end with a value
# in the cache of length 1 (the minimizer currently does not produce empty
# strings). check_cache.go confirms that.
#

go test -c -o t.exe -cover
exec ./t.exe

-- go.mod --
module hello

go 1.20
-- hello.go --
package hello

func Hello() {
	println("hello")
}

// contents not especially interesting, just need some code
func foo(n int) int {
	t := 0
	for i := 0; i < n; i++ {
		for j := 0; j < i; j++ {
			t += i ^ j
			if t == 1010101 {
				break
			}
		}
	}
	return t
}

//go:build ignore

package main

import (
	"log"
	"os"
	"runtime"
	"runtime/trace"
	"time"
)

func main() {
	// Start a goroutine that calls runtime.GC to try and
	// introduce some interesting events in between the
	// GOMAXPROCS calls.
	go func() {
		for {
			runtime.GC()
			time.Sleep(1 * time.Millisecond)
		}
	}()

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {