! go test -run=FuzzTargetGoexit
stdout cleanup

# Cleanup should run after panic.
! go test -run=FuzzTargetPanic
stdout cleanup

# Cleanup should run in fuzz function on seed corpus.
go test -v -run=FuzzFunction
stdout '(?s)inner.*outer'

# TODO(jayconrod): test cleanup while fuzzing. For now, the worker process's
# stdout and stderr is connected to the coordinator's, but it should eventually

				os.Exit(1)
			}
		}
		if !containsVal {
			fmt.Fprintln(os.Stderr, "corpus file contained no values")
			os.Exit(1)
		}
	}
}

var valRe = regexp.MustCompile(`^\[\]byte\(([^)]+)\)$`)

-- check_cache/check_cache.go --
//go:build ignore
// +build ignore

// check_cache.go checks that each file in the cached corpus has a []byte

go clean -fuzzcache
! exists $GOCACHE/fuzz
go build -x ./empty
! 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'

are not marked with `//go:linkname` on their definitions.
Similarly, the linker disallows references to such symbols from assembly
code.
For backward compatibility, existing usages of `//go:linkname` found in
a large open-source code corpus remain supported.
Any new references to standard library internal symbols will be disallowed.

A linker command line flag `-checklinkname=0` can be used to disable
this check, for debugging and experimenting purposes.

)

// encVersion1 will be the first line of a file with version 1 encoding.
var encVersion1 = "go test fuzz v1"

// marshalCorpusFile encodes an arbitrary number of arguments into the file format for the
// corpus.
func marshalCorpusFile(vals ...any) []byte {
	if len(vals) == 0 {
		panic("must have at least one value to marshal")
	}
	b := bytes.NewBuffer([]byte(encVersion1 + "\n"))

				return
			}
			if err != nil {
				t.Fatalf("unmarshal unexpected error: %v", err)
			}
			newB := marshalCorpusFile(vals...)
			if newB[len(newB)-1] != '\n' {
				t.Error("didn't write final newline to corpus file")
			}

			want := test.want
			if want == "" {
				want = test.in
			}
			want += "\n"
			got := string(newB)
			if got != want {

	// (AFL uses 32768, paired with a similar impl to chooseLen
	// which biases towards smaller lengths that grow over time),
	// or set the max based on characteristics of the corpus
	// (libFuzzer sets a min/max based on the min/max size of
	// entries in the corpus and then picks uniformly from
	// that range).
	n := m.chooseLen(4096)
	if len(b)+n >= cap(b) {
		return nil
	}
	b = b[:len(b)+n]
	copy(b[dst+n:], b[dst:])

	return func(collect func(string)) {
		for i := 0; i <= max; i++ {
			genRepeat(i, g)(collect)
		}
	}
}

func BenchmarkMultiConflicts(b *testing.B) {
	// How fast is indexing if the corpus is all multis?
	const nMultis = 1000
	var pats []*pattern
	for i := 0; i < nMultis; i++ {
		pats = append(pats, mustParsePattern(b, fmt.Sprintf("/a/b/{x}/d%d/", i)))
	}
	b.ResetTimer()

	// TODO(katiehockman): simplify this once we can dedupe crashes (e.g.
	// replace map with calls to panic, and simply count the number of crashes
	// that were added to testdata)
	crashes := make(map[string]bool)
	// No seed corpus initiated
	f.Fuzz(func(t *testing.T, b []byte) {
		crashes[string(b)] = true
		if len(crashes) >= 10 {
			panic("mutator found enough unique mutations")
		}
	})

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

package netip_test

import (
	"bytes"
	"encoding"
	"fmt"
	"net"
	. "net/netip"
	"reflect"
	"strings"
	"testing"
)

var corpus = []string{
	// Basic zero IPv4 address.
	"0.0.0.0",
	// Basic non-zero IPv4 address.
	"192.168.140.255",
	// IPv4 address in windows-style "print all the digits" form.
	"010.000.015.001",