"school_satchel":                       "\U0001f392",
	"scientist":                            "\U0001f9d1\u200d\U0001f52c",
	"scissors":                             "\u2702\ufe0f",
	"scorpion":                             "\U0001f982",
	"scorpius":                             "\u264f",
	"scotland":                             "\U0001f3f4\U000e0067\U000e0062\U000e0073\U000e0063\U000e0074\U000e007f",

	// countWaiting is the number of fuzzing executions the coordinator is
	// waiting on workers to complete.
	countWaiting int64

	// corpus is a set of interesting values, including the seed corpus and
	// generated values that workers reported as interesting.
	corpus corpus

	// minimizationAllowed is true if one or more of the types of fuzz
	// function's parameters can be minimized.
	minimizationAllowed bool

go mod verify


# If the module does include a test corpus, 'go test' (without '-fuzz') should
# load that corpus and run the fuzz tests against it, but 'go test -fuzz=.'
# should continue to be rejected.

go get -t example.com/fuzzfail@v0.2.0

! go test example.com/fuzzfail
stdout '^\s*fuzzfail_test\.go:7: oops:'

! go test -fuzz=. example.com/fuzzfail
! stdout .

	testContext *testContext

	// inFuzzFn is true when the fuzz function is running. Most F methods cannot
	// be called when inFuzzFn is true.
	inFuzzFn bool

	// corpus is a set of seed corpus entries, added with F.Add and loaded
	// from testdata.
	corpus []corpusEntry

	result     fuzzResult
	fuzzCalled bool
}

var _ TB = (*F)(nil)

// corpusEntry is an alias to the same type as internal/fuzz.CorpusEntry.

stdout FAIL
stdout 'failed some precondition'

# Test success with seed corpus in f.Fuzz
go test -run FuzzPass fuzz_add_test.go
stdout ok
! stdout FAIL
! stdout 'off by one error'

# Test fatal with seed corpus in f.Fuzz
! go test -run FuzzFatal fuzz_add_test.go
! stdout ^ok
stdout FAIL
stdout 'fatal here'

# Test panic with seed corpus in f.Fuzz
! go test -run FuzzPanic fuzz_add_test.go
! stdout ^ok

	fi

	(cd "${MC_BUILD_DIR}" && go build -o "$WORK_DIR/mc")

	# remove mc source.
	purge "${MC_BUILD_DIR}"

	"${WORK_DIR}/mc" cp --quiet -r "buildscripts/cicd-corpus/" "${WORK_DIR}/cicd-corpus/"

	"${MINIO[@]}" --address ":$start_port" "${WORK_DIR}/cicd-corpus/disk{1...5}" >"${WORK_DIR}/server1.log" 2>&1 &
	pid=$!
	disown $pid
	sleep 5

	if ! ps -p ${pid} 1>&2 >/dev/null; then
		echo "server1 log:"

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# This test checks that cached corpus loading properly handles duplicate entries (this can
# happen when a f.Add value has a duplicate entry in the cached corpus.) Duplicate entries
# should be discarded, and the rest of the cache should be loaded as normal.

env GOCACHE=$WORK/cache
env GODEBUG=fuzzdebug=1

mkdir -p $GOCACHE/fuzz/fuzztest/FuzzTarget
go run ./populate $GOCACHE/fuzz/fuzztest/FuzzTarget

! stdout ^ok
! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
stdout 'failure while testing seed corpus entry: FuzzWithTestdata/1'
stdout FAIL

# Test that fuzzing a target with no seed corpus or cache finds a crash, prints
# it, and write it to testdata
! go test -fuzz=FuzzWithNoCache -run=FuzzWithNoCache -fuzztime=1x
! stdout ^ok

stdout '=== RUN   FuzzFoo/thisfails'
stdout '--- FAIL: FuzzFoo/thisfails'
stdout '=== RUN   FuzzFoo/thispasses'
stdout '--- PASS: FuzzFoo/thispasses'
! stdout 'no tests to run'

# Tests where -run only matches one seed corpus which passes.

go test -run FuzzFoo/thispasses
stdout ok
! stdout 'no tests to run'

go test -run /thispasses
stdout ok
! stdout 'no tests to run'

# Same tests in verbose mode

# of the mutator finding a crash while fuzzing, adding it as a regression test
# to the seed corpus in testdata, and failing the next time the test is run.

[short] skip
env GOCACHE=$WORK/cache

# Running the seed corpus for all of the targets should pass the first
# time, since nothing in the seed corpus will cause a crash.
go test

# Running the fuzzer should find a crashing input quickly.