[dev.fuzz] testing: add support for testing.F.Add of []byte

Change-Id: I183693fec6a643b2f27cc379a422e2b42d8eca90
Reviewed-on: https://go-review.googlesource.com/c/go/+/255339
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Trust: Katie Hockman <katie@golang.org>

diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go
index ee7f68e5448873dac179b4f4d5c1648d94c47af1..d159f2e425d911ed6b4e0be5bb60c96c4094257c 100644 (file)
--- a/src/testing/fuzz.go
+++ b/src/testing/fuzz.go
@@ -39,11 +39,24 @@ type corpusEntry struct {
        b []byte
 }
 
-// Add will add the arguments to the seed corpus for the fuzz target. This
-// cannot be invoked after or within the Fuzz function. The args must match
+// Add will add the arguments to the seed corpus for the fuzz target. This will
+// be a no-op if called after or within the Fuzz function. The args must match
 // those in the Fuzz function.
 func (f *F) Add(args ...interface{}) {
-       return
+       if len(args) == 0 {
+               panic("testing: Add must have at least one argument")
+       }
+       if len(args) != 1 {
+               // TODO: support more than one argument
+               panic("testing: Add only supports one argument currently")
+       }
+       switch v := args[0].(type) {
+       case []byte:
+               f.corpus = append(f.corpus, corpusEntry{v})
+       // TODO: support other types
+       default:
+               panic("testing: Add only supports []byte currently")
+       }
 }
 
 // Fuzz runs the fuzz function, ff, for fuzz testing. It runs ff in a separate

diff --git a/src/testing/fuzz_test.go b/src/testing/fuzz_test.go
new file mode 100644 (file)
index 0000000..77a7d5e
--- /dev/null
+++ b/src/testing/fuzz_test.go
@@ -0,0 +1,42 @@
+package testing_test
+
+import (
+       "testing"
+)
+
+func TestFuzzAdd(t *testing.T) {
+       matchFunc := func(a, b string) (bool, error) { return true, nil }
+       tests := []struct {
+               name string
+               fn   func(f *testing.F)
+               ok   bool
+       }{
+               {
+                       "empty",
+                       func(f *testing.F) { f.Add() },
+                       false,
+               },
+               {
+                       "multiple arguments",
+                       func(f *testing.F) { f.Add([]byte("hello"), []byte("bye")) },
+                       false,
+               },
+               {
+                       "string",
+                       func(f *testing.F) { f.Add("hello") },
+                       false,
+               },
+               {
+                       "bytes",
+                       func(f *testing.F) { f.Add([]byte("hello")) },
+                       true,
+               },
+       }
+       for _, tc := range tests {
+               t.Run(tc.name, func(t *testing.T) {
+                       if got, want := testing.RunFuzzTargets(matchFunc, []testing.InternalFuzzTarget{{Fn: tc.fn}}), tc.ok; got != want {
+                               t.Errorf("testing.Add: ok %t, want %t", got, want)
+                       }
+               })
+       }
+}