src/cmd/go/testdata/script/test_fuzz.txt

# Test that calling f.Error in a fuzz target causes a non-zero exit status.
! go test -fuzz Fuzz error_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that calling f.Fatal in a fuzz target causes a non-zero exit status.
! go test fatal_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that successful test exits cleanly.
go test success_fuzz_test.go
stdout ok
! stdout FAIL

# Test that calling f.Fatal while fuzzing causes a non-zero exit status.
! go test -fuzz Fuzz fatal_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that successful fuzzing exits cleanly.
go test -fuzz Fuzz success_fuzz_test.go
stdout ok
! stdout FAIL

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

[short] stop

# Test that calling panic(nil) in a fuzz target causes a non-zero exit status.
! go test panic_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that skipped test exits cleanly.
go test skipped_fuzz_test.go
stdout ok
! stdout FAIL

# Test that f.Fatal within f.Fuzz panics
! go test fatal_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'fatal here'
stdout FAIL
stdout 'f.Fuzz function'

# Test that f.Error within f.Fuzz panics
! go test error_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'error here'
stdout FAIL
stdout 'f.Fuzz function'

# Test that f.Skip within f.Fuzz panics
! go test skip_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'skip here'
stdout FAIL
stdout 'f.Fuzz function'

# Test that a call to f.Fatal after the Fuzz func is never executed.
go test fatal_after_fuzz_func_fuzz_test.go
stdout ok
! stdout FAIL

# Test that missing *T in f.Fuzz causes a non-zero exit status.
! go test incomplete_fuzz_call_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that a panic in the Cleanup func is executed.
! go test cleanup_fuzz_test.go
! stdout ^ok
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
stdout FAIL
stdout 'off by one error'

# Test panic(nil) with seed corpus in f.Fuzz
! go test -run FuzzNilPanic fuzz_add_test.go
! stdout ^ok
stdout FAIL

# Test fatal with testdata seed corpus
! go test -run FuzzFail corpustesting/fuzz_testdata_corpus_test.go
! stdout ^ok
stdout FAIL
stdout 'fatal here'

# Test pass with testdata seed corpus
go test -run FuzzPass corpustesting/fuzz_testdata_corpus_test.go
stdout ok
! stdout FAIL
! stdout 'fatal here'

# Test pass with file in other nested testdata directory
go test -run FuzzInNestedDir corpustesting/fuzz_testdata_corpus_test.go
stdout ok
! stdout FAIL
! stdout 'fatal here'

-- error_fuzz_test.go --
package error_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Error("error in target")
}

-- fatal_fuzz_test.go --
package fatal_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Fatal("fatal in target")
}

-- panic_fuzz_test.go --
package panic_fuzz

import "testing"

func FuzzPanic(f *testing.F) {
    panic(nil)
}

-- success_fuzz_test.go --
package success_fuzz

import "testing"

func Fuzz(f *testing.F) {
}

-- skipped_fuzz_test.go --
package skipped_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Skip()
}

-- fatal_fuzz_fn_fuzz_test.go --
package fatal_fuzz_fn_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Add([]byte("aa"))
    f.Fuzz(func(t *testing.T, b []byte) {
        f.Fatal("fatal here")
    })
}

-- error_fuzz_fn_fuzz_test.go --
package error_fuzz_fn_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Add([]byte("aa"))
    f.Fuzz(func(t *testing.T, b []byte) {
        f.Error("error here")
    })
}

-- skip_fuzz_fn_fuzz_test.go --
package skip_fuzz_fn_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Add([]byte("aa"))
    f.Fuzz(func(t *testing.T, b []byte) {
        f.Skip("skip here")
    })
}

-- fatal_after_fuzz_func_fuzz_test.go --
package fatal_after_fuzz_func_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Fuzz(func(t *testing.T, b []byte) {
        // no-op
    })
    f.Fatal("this shouldn't be called")
}

-- incomplete_fuzz_call_fuzz_test.go --
package incomplete_fuzz_call_fuzz

import "testing"

func Fuzz(f *testing.F) {
    f.Fuzz(func(b []byte) {
        // this is missing *testing.T as the first param, so should panic
    })
}

-- cleanup_fuzz_test.go --
package cleanup_fuzz_test

import "testing"

func Fuzz(f *testing.F) {
    f.Cleanup(func() {
        panic("failed some precondition")
    })
    f.Fuzz(func(t *testing.T, b []byte) {
        // no-op
    })
}

-- fuzz_add_test.go --
package fuzz_add

import "testing"

func add(f *testing.F) {
    f.Helper()
    f.Add([]byte("123"))
    f.Add([]byte("12345"))
    f.Add([]byte(""))
}

func FuzzPass(f *testing.F) {
    add(f)
    f.Fuzz(func(t *testing.T, b []byte) {
        if len(b) == -1 {
            t.Fatal("fatal here") // will not be executed
        }
    })
}

func FuzzError(f *testing.F) {
    add(f)
    f.Fuzz(func(t *testing.T, b []byte) {
        if len(b) == 3 {
            t.Error("error here")
        }
    })
}

func FuzzFatal(f *testing.F) {
    add(f)
    f.Fuzz(func(t *testing.T, b []byte) {
        if len(b) == 0 {
            t.Fatal("fatal here")
        }
    })
}

func FuzzPanic(f *testing.F) {
    add(f)
    f.Fuzz(func(t *testing.T, b []byte) {
        if len(b) == 5 {
            panic("off by one error")
        }
    })
}

func FuzzNilPanic(f *testing.F) {
    add(f)
    f.Fuzz(func(t *testing.T, b []byte) {
        if len(b) == 3 {
            panic(nil)
        }
    })
}

-- corpustesting/fuzz_testdata_corpus_test.go --
package fuzz_testdata_corpus

import "testing"

func fuzzFn(f *testing.F) {
    f.Helper()
    f.Fuzz(func(t *testing.T, b []byte) {
        if string(b) == "12345\n" {
            t.Fatal("fatal here")
        }
    })
}

func FuzzFail(f *testing.F) {
    fuzzFn(f)
}

func FuzzPass(f *testing.F) {
    fuzzFn(f)
}

func FuzzInNestedDir(f *testing.F) {
    fuzzFn(f)
}

-- corpustesting/testdata/corpus/FuzzFail/1 --
12345
-- corpustesting/testdata/corpus/FuzzPass/1 --
00000
-- corpustesting/testdata/corpus/FuzzInNestedDir/anotherdir/1 --
12345