test: replace dvyukov/go-fuzz with native Go fuzzing (#153)

Author: rvagg

.github/dependabot.yml

@@ -3,6 +3,5 @@ updates:
   - package-ecosystem: "gomod"
     directories:
       - "/"
-      - "/fuzz/"
     schedule:
       interval: "monthly"

fuzz/.gitignore

@@ -1,3 +1,15 @@
 # Fuzzer to validate the AMT
 
-To fuzz, run `make`.
+Uses native Go fuzzing. Random byte input is decoded as a sequence of AMT
+operations (set, get, delete, flush, reload), mirrored into a plain map, and
+the AMT is checked against the map by iteration, random gets, and root CID
+reconstruction.
+
+To fuzz:
+
+    go test -fuzz=FuzzAMTOps .
+
+Seed corpus lives in `testdata/fuzz/FuzzAMTOps/` and is replayed by plain
+`go test`; commit minimised failing inputs there as regression tests. To
+trace ops while reproducing a failure, set `debug = true` in
+`checked_amt_test.go` and run with `-v`.

fuzz/Makefile

@@ -2,16 +2,23 @@ package fuzzer
 
 import (
 	"context"
-	"fmt"
 	"math/rand"
+	"testing"
 
 	cbor "github.com/ipfs/go-ipld-cbor"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/go-amt-ipld/v4"
 )
 
+// Set true to log each op when reproducing a failure with -v.
+const debug = false
+
+// checkedAMT mirrors every mutation into a plain map and verifies the AMT
+// against it: by iteration, by random get, and by reconstructing from
+// scratch to the same root CID.
 type checkedAMT struct {
+	t    *testing.T
 	amt  *amt.Root
 	step uint64
 	bs   cbor.IpldStore
@@ -21,13 +28,14 @@ type checkedAMT struct {
 	seen     map[uint64]struct{}
 }
 
-func newCheckedAMT() (*checkedAMT, error) {
+func newCheckedAMT(t *testing.T) (*checkedAMT, error) {
 	bs := cbor.NewCborStore(newMockBlocks())
 	root, err := amt.NewAMT(bs)
 	if err != nil {
 		return nil, err
 	}
 	return &checkedAMT{
+		t:     t,
 		amt:   root,
 		bs:    bs,
 		array: make(map[uint64]cbg.CborInt),
@@ -126,8 +134,8 @@ func (c *checkedAMT) reload() {
 
 func (c *checkedAMT) trace(msg string, args ...interface{}) {
 	c.step++
-	if Debug {
-		fmt.Printf("step %d: "+msg+"\n", append([]interface{}{c.step}, args...)...)
+	if debug {
+		c.t.Logf("step %d: "+msg, append([]interface{}{c.step}, args...)...)
 	}
 }
 
@@ -195,7 +203,7 @@ func (c *checkedAMT) checkByGet(array *amt.Root) {
 		found, err := array.Get(context.Background(), k, &actual)
 		c.checkErr(err)
 		if !found {
-			c.fail("expected to find key %s", k)
+			c.fail("expected to find key %d", k)
 		}
 		c.checkEq(c.array[k], actual)
 	}
@@ -228,5 +236,6 @@ func (c *checkedAMT) checkByIter(array *amt.Root) {
 }
 
 func (c *checkedAMT) fail(msg string, args ...interface{}) {
-	panic(fmt.Sprintf("step %d: "+msg, append([]interface{}{c.step}, args...)...))
+	c.t.Helper()
+	c.t.Fatalf("step %d: "+msg, append([]interface{}{c.step}, args...)...)
 }

fuzz/README.md

@@ -0,0 +1,110 @@
+package fuzzer
+
+import (
+	"encoding/binary"
+	"testing"
+
+	"github.com/filecoin-project/go-amt-ipld/v4"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+type opCode byte
+
+const (
+	opSet opCode = iota
+	opSetSeen
+	opGet
+	opGetSeen
+	opDelete
+	opDeleteSeen
+	opFlush
+	opReload
+	opMax
+)
+
+type op struct {
+	code  opCode
+	key   uint64
+	value cbg.CborInt
+}
+
+func parseOps(data []byte) (ops []op) {
+	scratch := make([]byte, 17)
+
+	for len(data) > 0 {
+		n := copy(scratch, data)
+		data = data[n:]
+
+		code := opCode(scratch[0] % byte(opMax))
+		k := binary.LittleEndian.Uint64(scratch[1:]) % amt.MaxIndex
+		v := binary.LittleEndian.Uint64(scratch[9:])
+		ops = append(ops, op{code, k, cbg.CborInt(v)})
+	}
+	return ops
+}
+
+func encodeOp(code opCode, key, value uint64) []byte {
+	buf := make([]byte, 17)
+	buf[0] = byte(code)
+	binary.LittleEndian.PutUint64(buf[1:], key)
+	binary.LittleEndian.PutUint64(buf[9:], value)
+	return buf
+}
+
+func seed(ops ...[]byte) (data []byte) {
+	for _, op := range ops {
+		data = append(data, op...)
+	}
+	return data
+}
+
+func FuzzAMTOps(f *testing.F) {
+	f.Add(seed(
+		encodeOp(opSet, 0, 100),
+		encodeOp(opSet, 1, 101),
+		encodeOp(opGet, 0, 0),
+		encodeOp(opFlush, 0, 0),
+		encodeOp(opDelete, 1, 0),
+	))
+	f.Add(seed(
+		encodeOp(opSet, amt.MaxIndex-1, 1),
+		encodeOp(opReload, 0, 0),
+		encodeOp(opGetSeen, 3, 0),
+		encodeOp(opDeleteSeen, 7, 0),
+		encodeOp(opSetSeen, 2, 42),
+	))
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		if len(data) < 1 {
+			return
+		}
+
+		arr, err := newCheckedAMT(t)
+		if err != nil {
+			t.Fatal("failed to construct AMT:", err)
+		}
+		for _, op := range parseOps(data) {
+			switch op.code {
+			case opSet:
+				arr.set(op.key, op.value)
+			case opSetSeen:
+				arr.setSeen(op.key, op.value)
+			case opGet:
+				arr.get(op.key)
+			case opGetSeen:
+				arr.getSeen(op.key)
+			case opDelete:
+				arr.delete(op.key)
+			case opDeleteSeen:
+				arr.deleteSeen(op.key)
+			case opFlush:
+				arr.flush()
+			case opReload:
+				arr.reload()
+			default:
+				panic("impossible")
+			}
+		}
+		arr.check()
+	})
+}