diff --git a/physical/gcs/gcs_test.go b/physical/gcs/gcs_test.go
index 9a602fc104..dda6eeddce 100644
--- a/physical/gcs/gcs_test.go
+++ b/physical/gcs/gcs_test.go
@@ -17,11 +17,6 @@ import (
 	"google.golang.org/api/option"
 )
 
-var ConsistencyDelays = physical.Delays{
-	BeforeList: 5 * time.Second,
-	BeforeGet:  0 * time.Second,
-}
-
 func TestGCSBackend(t *testing.T) {
 	credentialsFile := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS")
 
@@ -55,7 +50,6 @@ func TestGCSBackend(t *testing.T) {
 	defer func() {
 		objects_it := bucket.Objects(context.Background(), nil)
 
-		time.Sleep(ConsistencyDelays.BeforeList)
 		// have to delete all objects before deleting bucket
 		for {
 			objAttrs, err := objects_it.Next()
@@ -71,8 +65,6 @@ func TestGCSBackend(t *testing.T) {
 			bucket.Object(objAttrs.Name).Delete(context.Background())
 		}
 
-		// not a list operation, but google lists to make sure the bucket is empty on delete
-		time.Sleep(ConsistencyDelays.BeforeList)
 		err := bucket.Delete(context.Background())
 		if err != nil {
 			t.Fatalf("error deleting bucket '%s': '%v'", bucketName, err)
@@ -90,7 +82,7 @@ func TestGCSBackend(t *testing.T) {
 		t.Fatalf("error creating google cloud storage backend: '%s'", err)
 	}
 
-	physical.ExerciseEventuallyConsistentBackend(t, b, ConsistencyDelays)
-	physical.ExerciseEventuallyConsistentBackend_ListPrefix(t, b, ConsistencyDelays)
+	physical.ExerciseBackend(t, b)
+	physical.ExerciseBackend_ListPrefix(t, b)
 
 }
diff --git a/physical/testing.go b/physical/testing.go
index 1b434a2a31..69f7167598 100644
--- a/physical/testing.go
+++ b/physical/testing.go
@@ -341,278 +341,6 @@ func ExerciseHABackend(t *testing.T, b HABackend, b2 HABackend) {
 	lock2.Unlock()
 }
 
-type Delays struct {
-	BeforeGet  time.Duration
-	BeforeList time.Duration
-}
-
-func ExerciseEventuallyConsistentBackend(t *testing.T, b Backend, d Delays) {
-	// no delay required: nothing written to bucket
-	// Should be empty
-	keys, err := b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 0 {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Delete should work if it does not exist
-	err = b.Delete("foo")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// no delay required: nothing written to bucket
-	// Get should fail
-	out, err := b.Get("foo")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if out != nil {
-		t.Fatalf("bad: %v", out)
-	}
-
-	// Make an entry
-	e := &Entry{Key: "foo", Value: []byte("test")}
-	err = b.Put(e)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Get should work
-	time.Sleep(d.BeforeGet)
-	out, err = b.Get("foo")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if !reflect.DeepEqual(out, e) {
-		t.Fatalf("bad: %v expected: %v", out, e)
-	}
-
-	// List should not be empty
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 1 {
-		t.Fatalf("bad: %v", keys)
-	}
-	if keys[0] != "foo" {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Delete should work
-	err = b.Delete("foo")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Should be empty
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 0 {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Get should fail
-	time.Sleep(d.BeforeGet)
-	out, err = b.Get("foo")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if out != nil {
-		t.Fatalf("bad: %v", out)
-	}
-
-	// Multiple Puts should work; GH-189
-	e = &Entry{Key: "foo", Value: []byte("test")}
-	err = b.Put(e)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	e = &Entry{Key: "foo", Value: []byte("test")}
-	err = b.Put(e)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Make a nested entry
-	e = &Entry{Key: "foo/bar", Value: []byte("baz")}
-	err = b.Put(e)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 2 {
-		t.Fatalf("bad: %v", keys)
-	}
-	sort.Strings(keys)
-	if keys[0] != "foo" || keys[1] != "foo/" {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Delete with children should work
-	err = b.Delete("foo")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Get should return the child
-	time.Sleep(d.BeforeGet)
-	out, err = b.Get("foo/bar")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if out == nil {
-		t.Fatalf("missing child")
-	}
-
-	// Removal of nested secret should not leave artifacts
-	e = &Entry{Key: "foo/nested1/nested2/nested3", Value: []byte("baz")}
-	err = b.Put(e)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	err = b.Delete("foo/nested1/nested2/nested3")
-	if err != nil {
-		t.Fatalf("failed to remove nested secret: %v", err)
-	}
-
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("foo/")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	if len(keys) != 1 {
-		t.Fatalf("there should be only one key left after deleting nested "+
-			"secret: %v", keys)
-	}
-
-	if keys[0] != "bar" {
-		t.Fatalf("bad keys after deleting nested: %v", keys)
-	}
-
-	// Make a second nested entry to test prefix removal
-	e = &Entry{Key: "foo/zip", Value: []byte("zap")}
-	err = b.Put(e)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Delete should not remove the prefix
-	err = b.Delete("foo/bar")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 1 {
-		t.Fatalf("bad: %v", keys)
-	}
-	if keys[0] != "foo/" {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Delete should remove the prefix
-	err = b.Delete("foo/zip")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 0 {
-		t.Fatalf("bad: %v", keys)
-	}
-}
-
-func ExerciseEventuallyConsistentBackend_ListPrefix(t *testing.T, b Backend, d Delays) {
-	e1 := &Entry{Key: "foo", Value: []byte("test")}
-	e2 := &Entry{Key: "foo/bar", Value: []byte("test")}
-	e3 := &Entry{Key: "foo/bar/baz", Value: []byte("test")}
-
-	err := b.Put(e1)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	err = b.Put(e2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	err = b.Put(e3)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Scan the root
-	time.Sleep(d.BeforeList)
-	keys, err := b.List("")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 2 {
-		t.Fatalf("bad: %v", keys)
-	}
-	sort.Strings(keys)
-	if keys[0] != "foo" {
-		t.Fatalf("bad: %v", keys)
-	}
-	if keys[1] != "foo/" {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Scan foo/
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("foo/")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if len(keys) != 2 {
-		t.Fatalf("bad: %v", keys)
-	}
-	sort.Strings(keys)
-	if keys[0] != "bar" {
-		t.Fatalf("bad: %v", keys)
-	}
-	if keys[1] != "bar/" {
-		t.Fatalf("bad: %v", keys)
-	}
-
-	// Scan foo/bar/
-	time.Sleep(d.BeforeList)
-	keys, err = b.List("foo/bar/")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	sort.Strings(keys)
-	if len(keys) != 1 {
-		t.Fatalf("bad: %v", keys)
-	}
-	if keys[0] != "baz" {
-		t.Fatalf("bad: %v", keys)
-	}
-
-}
-
 func ExerciseTransactionalBackend(t *testing.T, b Backend) {
 	tb, ok := b.(Transactional)
 	if !ok {