# TODO(jayconrod): support shared memory on more platforms.
[!darwin] [!linux] [!windows] skip

# Test that running a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test noop_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that fuzzing a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test -fuzz=Fuzz -fuzztime=1x noop_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that calling f.Error in a fuzz target causes a non-zero exit status.
! go test -fuzz=Fuzz -fuzztime=1x 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 successful fuzzing exits cleanly.
go test -fuzz=Fuzz -fuzztime=1x 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 -fuzztime=1x fatal_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 runtime.Goexit within the fuzz function is an error.
! go test goexit_fuzz_fn_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that a call to f.Fatal after the Fuzz func is 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 panic with unsupported seed corpus
! go test -run FuzzUnsupported fuzz_add_test.go
! stdout ^ok
stdout FAIL

# Test panic with different number of args to f.Add
! go test -run FuzzAddDifferentNumber fuzz_add_test.go
! stdout ^ok
stdout FAIL

# Test panic with different type of args to f.Add
! go test -run FuzzAddDifferentType fuzz_add_test.go
! stdout ^ok
stdout FAIL

# Test that the wrong type given with f.Add will fail.
! go test -run FuzzWrongType 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 testdata and f.Add seed corpus
go test -run FuzzPassString corpustesting/fuzz_testdata_corpus_test.go
stdout ok
! stdout FAIL

# Fuzzing pass with testdata and f.Add seed corpus (skip running tests first)
go test -run=None -fuzz=FuzzPassString corpustesting/fuzz_testdata_corpus_test.go -fuzztime=10x
stdout ok
! stdout FAIL

# Fuzzing pass with testdata and f.Add seed corpus
go test -run=FuzzPassString -fuzz=FuzzPassString corpustesting/fuzz_testdata_corpus_test.go -fuzztime=10x
stdout ok
! stdout FAIL

# Test panic with malformed seed corpus
! go test -run FuzzFail corpustesting/fuzz_testdata_corpus_test.go
! stdout ^ok
stdout FAIL

# 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'

# Test fails with file containing wrong type
! go test -run FuzzWrongType corpustesting/fuzz_testdata_corpus_test.go
! stdout ^ok
stdout FAIL

-- noop_fuzz_test.go --
package noop_fuzz

import "testing"

func Fuzz(f *testing.F) {}

-- 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) {
    f.Fuzz(func (*testing.T, []byte) {})
}

-- 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")
    })
}

-- goexit_fuzz_fn_fuzz_test.go --
package goexit_fuzz_fn_fuzz

import "testing"

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

-- 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)
        }
    })
}

func FuzzUnsupported(f *testing.F) {
    m := make(map[string]bool)
    f.Add(m)
    f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzAddDifferentNumber(f *testing.F) {
    f.Add([]byte("a"))
    f.Add([]byte("a"), []byte("b"))
    f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzAddDifferentType(f *testing.F) {
    f.Add(false)
    f.Add(1234)
    f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzWrongType(f *testing.F) {
    f.Add("hello")
    f.Fuzz(func(*testing.T, []byte) {})
}

-- 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" {
            t.Fatal("fatal here")
        }
    })
}

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

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

func FuzzPassString(f *testing.F) {
    f.Add("some seed corpus")
    f.Fuzz(func(*testing.T, string) {})
}

func FuzzPanic(f *testing.F) {
    f.Fuzz(func(t *testing.T, b []byte) {})
}

func FuzzInNestedDir(f *testing.F) {
    f.Fuzz(func(t *testing.T, b []byte) {})
}

func FuzzWrongType(f *testing.F) {
    f.Fuzz(func(t *testing.T, b []byte) {})
}

-- corpustesting/testdata/fuzz/FuzzFail/1 --
go test fuzz v1
[]byte("12345")
-- corpustesting/testdata/fuzz/FuzzPass/1 --
go test fuzz v1
[]byte("00000")
-- corpustesting/testdata/fuzz/FuzzPassString/1 --
go test fuzz v1
string("hello")
-- corpustesting/testdata/fuzz/FuzzPanic/1 --
malformed
-- corpustesting/testdata/fuzz/FuzzInNestedDir/anotherdir/1 --
go test fuzz v1
[]byte("12345")
-- corpustesting/testdata/fuzz/FuzzWrongType/1 --
go test fuzz v1
int("00000")