test: avoid fuzzing while the race detector is enabled

It's too slow.

buzhash_norace_test.go

+//+build !race
+
+package chunk
+
+import (
+	"testing"
+)
+
+func TestFuzzBuzhashChunking(t *testing.T) {
+	buf := make([]byte, 1024*1024*16)
+	for i := 0; i < 100; i++ {
+		testBuzhashChunking(t, buf)
+	}
+}

buzhash_test.go

@@ -8,50 +8,50 @@ import (
 	util "github.com/ipfs/go-ipfs-util"
 )
 
-func TestBuzhashChunking(t *testing.T) {
-	data := make([]byte, 1024*1024*16)
-
-	chunkCount := 0
-	rounds := 100
+func testBuzhashChunking(t *testing.T, buf []byte) (chunkCount int) {
+	util.NewTimeSeededRand().Read(buf)
 
-	for i := 0; i < rounds; i++ {
-		util.NewTimeSeededRand().Read(data)
+	r := NewBuzhash(bytes.NewReader(buf))
 
-		r := NewBuzhash(bytes.NewReader(data))
+	var chunks [][]byte
 
-		var chunks [][]byte
-
-		for {
-			chunk, err := r.NextBytes()
-			if err != nil {
-				if err == io.EOF {
-					break
-				}
-				t.Fatal(err)
+	for {
+		chunk, err := r.NextBytes()
+		if err != nil {
+			if err == io.EOF {
+				break
 			}
-
-			chunks = append(chunks, chunk)
+			t.Fatal(err)
 		}
-		chunkCount += len(chunks)
 
-		for i, chunk := range chunks {
-			if len(chunk) == 0 {
-				t.Fatalf("chunk %d/%d is empty", i+1, len(chunks))
-			}
-		}
+		chunks = append(chunks, chunk)
+	}
+	chunkCount += len(chunks)
 
-		for i, chunk := range chunks[:len(chunks)-1] {
-			if len(chunk) < buzMin {
-				t.Fatalf("chunk %d/%d is less than the minimum size", i+1, len(chunks))
-			}
+	for i, chunk := range chunks {
+		if len(chunk) == 0 {
+			t.Fatalf("chunk %d/%d is empty", i+1, len(chunks))
 		}
+	}
 
-		unchunked := bytes.Join(chunks, nil)
-		if !bytes.Equal(unchunked, data) {
-			t.Fatal("data was chunked incorrectly")
+	for i, chunk := range chunks[:len(chunks)-1] {
+		if len(chunk) < buzMin {
+			t.Fatalf("chunk %d/%d is less than the minimum size", i+1, len(chunks))
 		}
 	}
-	t.Logf("average block size: %d\n", len(data)*rounds/chunkCount)
+
+	unchunked := bytes.Join(chunks, nil)
+	if !bytes.Equal(unchunked, buf) {
+		t.Fatal("data was chunked incorrectly")
+	}
+
+	return chunkCount
+}
+
+func TestBuzhashChunking(t *testing.T) {
+	buf := make([]byte, 1024*1024*16)
+	count := testBuzhashChunking(t, buf)
+	t.Logf("average block size: %d\n", len(buf)/count)
 }
 
 func TestBuzhashChunkReuse(t *testing.T) {