mirror of https://github.com/golang/go.git
499 lines
10 KiB
Plaintext
499 lines
10 KiB
Plaintext
[!fuzz] 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.Fail within f.Fuzz panics
|
|
! go test fail_fuzz_fn_fuzz_test.go
|
|
! stdout ^ok
|
|
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 f.Skipped within f.Fuzz panics
|
|
! go test skipped_fuzz_fn_fuzz_test.go
|
|
! stdout ^ok
|
|
! stdout 'f.Skipped is'
|
|
stdout FAIL
|
|
stdout 'f.Fuzz function'
|
|
stdout 't.Skipped is false'
|
|
|
|
# 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 '\[string int\], want \[\[\]uint8 int8\]'
|
|
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")
|
|
})
|
|
}
|
|
|
|
-- fail_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.Fail()
|
|
})
|
|
}
|
|
|
|
-- 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")
|
|
})
|
|
}
|
|
|
|
-- skipped_fuzz_fn_fuzz_test.go --
|
|
package skipped_fuzz_fn_fuzz
|
|
|
|
import "testing"
|
|
|
|
func Fuzz(f *testing.F) {
|
|
f.Add([]byte("aa"))
|
|
f.Fuzz(func(t *testing.T, b []byte) {
|
|
t.Logf("t.Skipped is %t\n", t.Skipped())
|
|
t.Logf("f.Skipped is %t\n", f.Skipped())
|
|
})
|
|
}
|
|
|
|
-- 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", 50)
|
|
f.Fuzz(func(*testing.T, []byte, int8) {})
|
|
}
|
|
|
|
-- 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")
|