File size: 11,080 Bytes

e36aeda

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

# This test uses -vet=off to suppress vet, as vet's "tests" analyzer would
# otherwise statically report the problems we are trying to observe dynamically.

# Test that running a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test -vet=off 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 -vet=off -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 -vet=off -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 -vet=off fatal_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that successful test exits cleanly.
go test -vet=off success_fuzz_test.go
stdout ^ok
! stdout FAIL

# Test that successful fuzzing exits cleanly.
go test -vet=off -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 -vet=off -fuzz=Fuzz -fuzztime=1x fatal_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test error with seed corpus in f.Fuzz
! go test -vet=off -run Fuzz_error -vet=off 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 -vet=off panic_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that skipped test exits cleanly.
go test -vet=off skipped_fuzz_test.go
stdout ok
! stdout FAIL

# Test that f.Fatal within f.Fuzz panics
! go test -vet=off fatal_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'fatal here'
stdout FAIL
stdout 'fuzz target'

# Test that f.Error within f.Fuzz panics
! go test -vet=off error_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'error here'
stdout FAIL
stdout 'fuzz target'

# Test that f.Fail within f.Fuzz panics
! go test -vet=off fail_fuzz_fn_fuzz_test.go
! stdout ^ok
stdout FAIL
stdout 'fuzz target'

# Test that f.Skip within f.Fuzz panics
! go test -vet=off skip_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'skip here'
stdout FAIL
stdout 'fuzz target'

# Test that f.Skipped within f.Fuzz panics
! go test -vet=off skipped_fuzz_fn_fuzz_test.go
! stdout ^ok
! stdout 'f.Skipped is'
stdout FAIL
stdout 'fuzz target'
stdout 't.Skipped is false'

# Test that runtime.Goexit within the fuzz function is an error.
! go test -vet=off 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 -vet=off 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 -vet=off incomplete_fuzz_call_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that a panic in the Cleanup func is executed.
! go test -vet=off cleanup_fuzz_test.go
! stdout ^ok
stdout FAIL
stdout 'failed some precondition'

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

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

# Test panic with seed corpus in f.Fuzz
! go test -vet=off -run Fuzz_panic -vet=off fuzz_add_test.go
! stdout ^ok
stdout FAIL
stdout 'off by one error'

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

# Test panic with unsupported seed corpus
! go test -vet=off -run Fuzz_unsupported -vet=off fuzz_add_test.go
! stdout ^ok
stdout FAIL

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

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

# Test that the wrong type given with f.Add will fail.
! go test -vet=off -run Fuzz_wrongType -vet=off fuzz_add_test.go
! stdout ^ok
stdout '\[string int\], want \[\[\]uint8 int8\]'
stdout FAIL

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

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

# Test pass with testdata and f.Add seed corpus
go test -vet=off -run Fuzz_passString 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 -vet=off -run=None -fuzz=Fuzz_passString corpustesting/fuzz_testdata_corpus_test.go -fuzztime=10x
stdout ok
! stdout FAIL

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

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

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

# Test fails with file containing wrong type
! go test -vet=off -run Fuzz_wrongType 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 Fuzz_panic(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 Fuzz_pass(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 Fuzz_error(f *testing.F) {
    add(f)
    f.Fuzz(func(t *testing.T, b []byte) {
        if len(b) == 3 {
            t.Error("error here")
        }
    })
}

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

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

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

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

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

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

func Fuzz_wrongType(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 Fuzz_fail(f *testing.F) {
    fuzzFn(f)
}

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

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

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

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

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

-- corpustesting/testdata/fuzz/Fuzz_fail/1 --
go test fuzz v1
[]byte("12345")
-- corpustesting/testdata/fuzz/Fuzz_pass/1 --
go test fuzz v1
[]byte("00000")
-- corpustesting/testdata/fuzz/Fuzz_passString/1 --
go test fuzz v1
string("hello")
-- corpustesting/testdata/fuzz/Fuzz_panic/1 --
malformed
-- corpustesting/testdata/fuzz/Fuzz_inNestedDir/anotherdir/1 --
go test fuzz v1
[]byte("12345")
-- corpustesting/testdata/fuzz/Fuzz_wrongType/1 --
go test fuzz v1
int("00000")