diff --git a/.circleci/config.yml b/.circleci/config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6258fe5a23fbe68485e4406478952d049bf926b9
--- /dev/null
+++ b/.circleci/config.yml
@@ -0,0 +1,14 @@
+version: 2.1
+orbs:
+  ci-go: ipfs/ci-go@0.2
+
+workflows:
+  version: 2
+  test:
+    jobs:
+      - ci-go/build
+      - ci-go/lint
+      - ci-go/test
+      - ci-go/test:
+          race: true
+          name: "ci-go/test/race"
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index f32dfd14c65e4434162ab18cb36ef68f3bc02ac4..0000000000000000000000000000000000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-os:
-  - linux
-
-language: go
-
-go:
-  - 1.11.x
-
-env:
-  global:
-    - GOTFLAGS="-race"
-    - BUILD_DEPTYPE=gomod
-
-# disable travis install
-install:
-  - true
-
-script:
-  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
-
-
-cache:
-  directories:
-    - $GOPATH/pkg/mod
-    - $HOME/.cache/go-build
-
-notifications:
-  email: false
diff --git a/buzhash_norace_test.go b/buzhash_norace_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2565a4c5338fe3303e529df23871ee652e76bca2
--- /dev/null
+++ b/buzhash_norace_test.go
@@ -0,0 +1,14 @@
+//+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)
+	}
+}
diff --git a/buzhash_test.go b/buzhash_test.go
index 07573bab6b60d80144c6a2b7ad300543ac59c2c9..05ad7c380fec042c2a10a19a18293c868e8dcf73 100644
--- a/buzhash_test.go
+++ b/buzhash_test.go
@@ -8,50 +8,56 @@ import (
 	util "github.com/ipfs/go-ipfs-util"
 )
 
-func TestBuzhashChunking(t *testing.T) {
-	data := make([]byte, 1024*1024*16)
-
-	chunkCount := 0
-	rounds := 100
-
-	for i := 0; i < rounds; i++ {
-		util.NewTimeSeededRand().Read(data)
+func testBuzhashChunking(t *testing.T, buf []byte) (chunkCount int) {
+	n, err := util.NewTimeSeededRand().Read(buf)
+	if n < len(buf) {
+		t.Fatalf("expected %d bytes, got %d", len(buf), n)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
 
-		r := NewBuzhash(bytes.NewReader(data))
+	r := NewBuzhash(bytes.NewReader(buf))
 
-		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) {
diff --git a/rabin_test.go b/rabin_test.go
index 857e97c2ca1ef528d75ed69970e1b73449feb2ba..2e19a82c74b25c5b0f38d329f11ce31f5822bc37 100644
--- a/rabin_test.go
+++ b/rabin_test.go
@@ -12,7 +12,13 @@ import (
 
 func TestRabinChunking(t *testing.T) {
 	data := make([]byte, 1024*1024*16)
-	util.NewTimeSeededRand().Read(data)
+	n, err := util.NewTimeSeededRand().Read(data)
+	if n < len(data) {
+		t.Fatalf("expected %d bytes, got %d", len(data), n)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	r := NewRabin(bytes.NewReader(data), 1024*256)
 
@@ -62,7 +68,13 @@ func chunkData(t *testing.T, newC newSplitter, data []byte) map[string]blocks.Bl
 
 func testReuse(t *testing.T, cr newSplitter) {
 	data := make([]byte, 1024*1024*16)
-	util.NewTimeSeededRand().Read(data)
+	n, err := util.NewTimeSeededRand().Read(data)
+	if n < len(data) {
+		t.Fatalf("expected %d bytes, got %d", len(data), n)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	ch1 := chunkData(t, cr, data[1000:])
 	ch2 := chunkData(t, cr, data)