diff --git a/cmd/restic/integration_fuse_test.go b/cmd/restic/integration_fuse_test.go
index 0a3bde4dc..1a65d803b 100644
--- a/cmd/restic/integration_fuse_test.go
+++ b/cmd/restic/integration_fuse_test.go
@@ -13,7 +13,7 @@ import (
 
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	"github.com/restic/restic/internal/test"
 )
 
 const (
@@ -56,7 +56,7 @@ func waitForMount(t testing.TB, dir string) {
 
 func testRunMount(t testing.TB, gopts GlobalOptions, dir string) {
 	opts := MountOptions{}
-	OK(t, runMount(opts, gopts, []string{dir}))
+	test.OK(t, runMount(opts, gopts, []string{dir}))
 }
 
 func testRunUmount(t testing.TB, gopts GlobalOptions, dir string) {
@@ -75,10 +75,10 @@ func testRunUmount(t testing.TB, gopts GlobalOptions, dir string) {
 
 func listSnapshots(t testing.TB, dir string) []string {
 	snapshotsDir, err := os.Open(filepath.Join(dir, "snapshots"))
-	OK(t, err)
+	test.OK(t, err)
 	names, err := snapshotsDir.Readdirnames(-1)
-	OK(t, err)
-	OK(t, snapshotsDir.Close())
+	test.OK(t, err)
+	test.OK(t, snapshotsDir.Close())
 	return names
 }
 
@@ -98,7 +98,7 @@ func checkSnapshots(t testing.TB, global GlobalOptions, repo *repository.Reposit
 
 	namesInSnapshots := listSnapshots(t, mountpoint)
 	t.Logf("found %v snapshots in fuse mount: %v", len(namesInSnapshots), namesInSnapshots)
-	Assert(t,
+	test.Assert(t,
 		expectedSnapshotsInFuseDir == len(namesInSnapshots),
 		"Invalid number of snapshots: expected %d, got %d", expectedSnapshotsInFuseDir, len(namesInSnapshots))
 
@@ -119,7 +119,7 @@ func checkSnapshots(t testing.TB, global GlobalOptions, repo *repository.Reposit
 
 	for _, id := range snapshotIDs {
 		snapshot, err := restic.LoadSnapshot(context.TODO(), repo, id)
-		OK(t, err)
+		test.OK(t, err)
 
 		ts := snapshot.Time.Format(time.RFC3339)
 		present, ok := namesMap[ts]
@@ -143,12 +143,12 @@ func checkSnapshots(t testing.TB, global GlobalOptions, repo *repository.Reposit
 	}
 
 	for name, present := range namesMap {
-		Assert(t, present, "Directory %s is present in fuse dir but is not a snapshot", name)
+		test.Assert(t, present, "Directory %s is present in fuse dir but is not a snapshot", name)
 	}
 }
 
 func TestMount(t *testing.T) {
-	if !RunFuseTest {
+	if !test.RunFuseTest {
 		t.Skip("Skipping fuse tests")
 	}
 
@@ -158,19 +158,19 @@ func TestMount(t *testing.T) {
 	testRunInit(t, env.gopts)
 
 	repo, err := OpenRepository(env.gopts)
-	OK(t, err)
+	test.OK(t, err)
 
 	// We remove the mountpoint now to check that cmdMount creates it
-	RemoveAll(t, env.mountpoint)
+	test.RemoveAll(t, env.mountpoint)
 
 	checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, []restic.ID{}, 0)
 
-	SetupTarTestFixture(t, env.testdata, filepath.Join("testdata", "backup-data.tar.gz"))
+	test.SetupTarTestFixture(t, env.testdata, filepath.Join("testdata", "backup-data.tar.gz"))
 
 	// first backup
 	testRunBackup(t, []string{env.testdata}, BackupOptions{}, env.gopts)
 	snapshotIDs := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 1,
+	test.Assert(t, len(snapshotIDs) == 1,
 		"expected one snapshot, got %v", snapshotIDs)
 
 	checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, snapshotIDs, 2)
@@ -178,7 +178,7 @@ func TestMount(t *testing.T) {
 	// second backup, implicit incremental
 	testRunBackup(t, []string{env.testdata}, BackupOptions{}, env.gopts)
 	snapshotIDs = testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 2,
+	test.Assert(t, len(snapshotIDs) == 2,
 		"expected two snapshots, got %v", snapshotIDs)
 
 	checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, snapshotIDs, 3)
@@ -187,24 +187,24 @@ func TestMount(t *testing.T) {
 	bopts := BackupOptions{Parent: snapshotIDs[0].String()}
 	testRunBackup(t, []string{env.testdata}, bopts, env.gopts)
 	snapshotIDs = testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 3,
+	test.Assert(t, len(snapshotIDs) == 3,
 		"expected three snapshots, got %v", snapshotIDs)
 
 	checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, snapshotIDs, 4)
 }
 
 func TestMountSameTimestamps(t *testing.T) {
-	if !RunFuseTest {
+	if !test.RunFuseTest {
 		t.Skip("Skipping fuse tests")
 	}
 
 	env, cleanup := withTestEnvironment(t)
 	defer cleanup()
 
-	SetupTarTestFixture(t, env.base, filepath.Join("testdata", "repo-same-timestamps.tar.gz"))
+	test.SetupTarTestFixture(t, env.base, filepath.Join("testdata", "repo-same-timestamps.tar.gz"))
 
 	repo, err := OpenRepository(env.gopts)
-	OK(t, err)
+	test.OK(t, err)
 
 	ids := []restic.ID{
 		restic.TestParseID("280303689e5027328889a06d718b729e96a1ce6ae9ef8290bff550459ae611ee"),
diff --git a/cmd/restic/integration_helpers_test.go b/cmd/restic/integration_helpers_test.go
index 305929b6a..954a6dae4 100644
--- a/cmd/restic/integration_helpers_test.go
+++ b/cmd/restic/integration_helpers_test.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/restic/restic/internal/options"
 	"github.com/restic/restic/internal/repository"
-	. "github.com/restic/restic/internal/test"
+	"github.com/restic/restic/internal/test"
 )
 
 type dirEntry struct {
@@ -174,14 +174,14 @@ type testEnvironment struct {
 // withTestEnvironment creates a test environment and returns a cleanup
 // function which removes it.
 func withTestEnvironment(t testing.TB) (env *testEnvironment, cleanup func()) {
-	if !RunIntegrationTest {
+	if !test.RunIntegrationTest {
 		t.Skip("integration tests disabled")
 	}
 
 	repository.TestUseLowSecurityKDFParameters(t)
 
-	tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-")
-	OK(t, err)
+	tempdir, err := ioutil.TempDir(test.TestTempDir, "restic-test-")
+	test.OK(t, err)
 
 	env = &testEnvironment{
 		base:       tempdir,
@@ -191,17 +191,17 @@ func withTestEnvironment(t testing.TB) (env *testEnvironment, cleanup func()) {
 		mountpoint: filepath.Join(tempdir, "mount"),
 	}
 
-	OK(t, os.MkdirAll(env.mountpoint, 0700))
-	OK(t, os.MkdirAll(env.testdata, 0700))
-	OK(t, os.MkdirAll(env.cache, 0700))
-	OK(t, os.MkdirAll(env.repo, 0700))
+	test.OK(t, os.MkdirAll(env.mountpoint, 0700))
+	test.OK(t, os.MkdirAll(env.testdata, 0700))
+	test.OK(t, os.MkdirAll(env.cache, 0700))
+	test.OK(t, os.MkdirAll(env.repo, 0700))
 
 	env.gopts = GlobalOptions{
 		Repo:     env.repo,
 		Quiet:    true,
 		CacheDir: env.cache,
 		ctx:      context.Background(),
-		password: TestPassword,
+		password: test.TestPassword,
 		stdout:   os.Stdout,
 		stderr:   os.Stderr,
 		extended: make(options.Options),
@@ -211,11 +211,11 @@ func withTestEnvironment(t testing.TB) (env *testEnvironment, cleanup func()) {
 	globalOptions = env.gopts
 
 	cleanup = func() {
-		if !TestCleanupTempDirs {
+		if !test.TestCleanupTempDirs {
 			t.Logf("leaving temporary directory %v used for test", tempdir)
 			return
 		}
-		RemoveAll(t, tempdir)
+		test.RemoveAll(t, tempdir)
 	}
 
 	return env, cleanup
diff --git a/cmd/restic/integration_test.go b/cmd/restic/integration_test.go
index 449b1c93e..86e4bbf5e 100644
--- a/cmd/restic/integration_test.go
+++ b/cmd/restic/integration_test.go
@@ -17,13 +17,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/restic/restic/internal/errors"
-	"github.com/restic/restic/internal/restic"
-
 	"github.com/restic/restic/internal/debug"
+	"github.com/restic/restic/internal/errors"
 	"github.com/restic/restic/internal/filter"
 	"github.com/restic/restic/internal/repository"
-	. "github.com/restic/restic/internal/test"
+	"github.com/restic/restic/internal/restic"
+	"github.com/restic/restic/internal/test"
 )
 
 func parseIDsFromReader(t testing.TB, rd io.Reader) restic.IDs {
@@ -47,13 +46,13 @@ func testRunInit(t testing.TB, opts GlobalOptions) {
 	repository.TestUseLowSecurityKDFParameters(t)
 	restic.TestSetLockTimeout(t, 0)
 
-	OK(t, runInit(opts, nil))
+	test.OK(t, runInit(opts, nil))
 	t.Logf("repository initialized at %v", opts.Repo)
 }
 
 func testRunBackup(t testing.TB, target []string, opts BackupOptions, gopts GlobalOptions) {
 	t.Logf("backing up %v", target)
-	OK(t, runBackup(opts, gopts, target))
+	test.OK(t, runBackup(opts, gopts, target))
 }
 
 func testRunList(t testing.TB, tpe string, opts GlobalOptions) restic.IDs {
@@ -63,7 +62,7 @@ func testRunList(t testing.TB, tpe string, opts GlobalOptions) restic.IDs {
 		globalOptions.stdout = os.Stdout
 	}()
 
-	OK(t, runList(opts, []string{tpe}))
+	test.OK(t, runList(opts, []string{tpe}))
 	return parseIDsFromReader(t, buf)
 }
 
@@ -78,7 +77,7 @@ func testRunRestoreLatest(t testing.TB, gopts GlobalOptions, dir string, paths [
 		Paths:  paths,
 	}
 
-	OK(t, runRestore(opts, gopts, []string{"latest"}))
+	test.OK(t, runRestore(opts, gopts, []string{"latest"}))
 }
 
 func testRunRestoreExcludes(t testing.TB, gopts GlobalOptions, dir string, snapshotID restic.ID, excludes []string) {
@@ -87,7 +86,7 @@ func testRunRestoreExcludes(t testing.TB, gopts GlobalOptions, dir string, snaps
 		Exclude: excludes,
 	}
 
-	OK(t, runRestore(opts, gopts, []string{snapshotID.String()}))
+	test.OK(t, runRestore(opts, gopts, []string{snapshotID.String()}))
 }
 
 func testRunRestoreIncludes(t testing.TB, gopts GlobalOptions, dir string, snapshotID restic.ID, includes []string) {
@@ -96,7 +95,7 @@ func testRunRestoreIncludes(t testing.TB, gopts GlobalOptions, dir string, snaps
 		Include: includes,
 	}
 
-	OK(t, runRestore(opts, gopts, []string{snapshotID.String()}))
+	test.OK(t, runRestore(opts, gopts, []string{snapshotID.String()}))
 }
 
 func testRunCheck(t testing.TB, gopts GlobalOptions) {
@@ -104,7 +103,7 @@ func testRunCheck(t testing.TB, gopts GlobalOptions) {
 		ReadData:    true,
 		CheckUnused: true,
 	}
-	OK(t, runCheck(opts, gopts, nil))
+	test.OK(t, runCheck(opts, gopts, nil))
 }
 
 func testRunCheckOutput(gopts GlobalOptions) (string, error) {
@@ -129,7 +128,7 @@ func testRunRebuildIndex(t testing.TB, gopts GlobalOptions) {
 		globalOptions.stdout = os.Stdout
 	}()
 
-	OK(t, runRebuildIndex(gopts))
+	test.OK(t, runRebuildIndex(gopts))
 }
 
 func testRunLs(t testing.TB, gopts GlobalOptions, snapshotID string) []string {
@@ -144,7 +143,7 @@ func testRunLs(t testing.TB, gopts GlobalOptions, snapshotID string) []string {
 
 	opts := LsOptions{}
 
-	OK(t, runLs(opts, gopts, []string{snapshotID}))
+	test.OK(t, runLs(opts, gopts, []string{snapshotID}))
 
 	return strings.Split(string(buf.Bytes()), "\n")
 }
@@ -160,7 +159,7 @@ func testRunFind(t testing.TB, wantJSON bool, gopts GlobalOptions, pattern strin
 
 	opts := FindOptions{}
 
-	OK(t, runFind(opts, gopts, []string{pattern}))
+	test.OK(t, runFind(opts, gopts, []string{pattern}))
 
 	return buf.Bytes()
 }
@@ -176,10 +175,10 @@ func testRunSnapshots(t testing.TB, gopts GlobalOptions) (newest *Snapshot, snap
 
 	opts := SnapshotOptions{}
 
-	OK(t, runSnapshots(opts, globalOptions, []string{}))
+	test.OK(t, runSnapshots(opts, globalOptions, []string{}))
 
 	snapshots := []Snapshot{}
-	OK(t, json.Unmarshal(buf.Bytes(), &snapshots))
+	test.OK(t, json.Unmarshal(buf.Bytes(), &snapshots))
 
 	snapmap = make(map[restic.ID]Snapshot, len(snapshots))
 	for _, sn := range snapshots {
@@ -193,11 +192,11 @@ func testRunSnapshots(t testing.TB, gopts GlobalOptions) (newest *Snapshot, snap
 
 func testRunForget(t testing.TB, gopts GlobalOptions, args ...string) {
 	opts := ForgetOptions{}
-	OK(t, runForget(opts, gopts, args))
+	test.OK(t, runForget(opts, gopts, args))
 }
 
 func testRunPrune(t testing.TB, gopts GlobalOptions) {
-	OK(t, runPrune(gopts))
+	test.OK(t, runPrune(gopts))
 }
 
 func TestBackup(t *testing.T) {
@@ -210,18 +209,18 @@ func TestBackup(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
 	testRunInit(t, env.gopts)
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 	opts := BackupOptions{}
 
 	// first backup
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	snapshotIDs := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 1,
+	test.Assert(t, len(snapshotIDs) == 1,
 		"expected one snapshot, got %v", snapshotIDs)
 
 	testRunCheck(t, env.gopts)
@@ -230,7 +229,7 @@ func TestBackup(t *testing.T) {
 	// second backup, implicit incremental
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	snapshotIDs = testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 2,
+	test.Assert(t, len(snapshotIDs) == 2,
 		"expected two snapshots, got %v", snapshotIDs)
 
 	stat2 := dirStats(env.repo)
@@ -244,7 +243,7 @@ func TestBackup(t *testing.T) {
 	opts.Parent = snapshotIDs[0].String()
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	snapshotIDs = testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 3,
+	test.Assert(t, len(snapshotIDs) == 3,
 		"expected three snapshots, got %v", snapshotIDs)
 
 	stat3 := dirStats(env.repo)
@@ -258,7 +257,7 @@ func TestBackup(t *testing.T) {
 		restoredir := filepath.Join(env.base, fmt.Sprintf("restore%d", i))
 		t.Logf("restoring snapshot %v to %v", snapshotID.Str(), restoredir)
 		testRunRestore(t, env.gopts, restoredir, snapshotIDs[0])
-		Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")),
+		test.Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")),
 			"directories are not equal")
 	}
 
@@ -275,10 +274,10 @@ func TestBackupNonExistingFile(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	testRunInit(t, env.gopts)
 	globalOptions.stderr = ioutil.Discard
@@ -309,10 +308,10 @@ func TestBackupMissingFile1(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	testRunInit(t, env.gopts)
 	globalOptions.stderr = ioutil.Discard
@@ -331,7 +330,7 @@ func TestBackupMissingFile1(t *testing.T) {
 		t.Logf("in hook, removing test file testdata/0/0/9/37")
 		ranHook = true
 
-		OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37")))
+		test.OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37")))
 	})
 
 	opts := BackupOptions{}
@@ -339,7 +338,7 @@ func TestBackupMissingFile1(t *testing.T) {
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 
-	Assert(t, ranHook, "hook did not run")
+	test.Assert(t, ranHook, "hook did not run")
 	debug.RemoveHook("pipe.walk1")
 }
 
@@ -353,10 +352,10 @@ func TestBackupMissingFile2(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	testRunInit(t, env.gopts)
 
@@ -376,7 +375,7 @@ func TestBackupMissingFile2(t *testing.T) {
 		t.Logf("in hook, removing test file testdata/0/0/9/37")
 		ranHook = true
 
-		OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37")))
+		test.OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37")))
 	})
 
 	opts := BackupOptions{}
@@ -384,7 +383,7 @@ func TestBackupMissingFile2(t *testing.T) {
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 
-	Assert(t, ranHook, "hook did not run")
+	test.Assert(t, ranHook, "hook did not run")
 	debug.RemoveHook("pipe.walk2")
 }
 
@@ -398,10 +397,10 @@ func TestBackupChangedFile(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	testRunInit(t, env.gopts)
 
@@ -423,7 +422,7 @@ func TestBackupChangedFile(t *testing.T) {
 		t.Logf("in hook, modifying test file %v", modFile)
 		ranHook = true
 
-		OK(t, ioutil.WriteFile(modFile, []byte("modified"), 0600))
+		test.OK(t, ioutil.WriteFile(modFile, []byte("modified"), 0600))
 	})
 
 	opts := BackupOptions{}
@@ -431,7 +430,7 @@ func TestBackupChangedFile(t *testing.T) {
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 
-	Assert(t, ranHook, "hook did not run")
+	test.Assert(t, ranHook, "hook did not run")
 	debug.RemoveHook("archiver.SaveFile")
 }
 
@@ -445,10 +444,10 @@ func TestBackupDirectoryError(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	testRunInit(t, env.gopts)
 
@@ -472,22 +471,22 @@ func TestBackupDirectoryError(t *testing.T) {
 		t.Logf("in hook, removing test file %v", testdir)
 		ranHook = true
 
-		OK(t, os.RemoveAll(testdir))
+		test.OK(t, os.RemoveAll(testdir))
 	})
 
 	testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0")}, BackupOptions{}, env.gopts)
 	testRunCheck(t, env.gopts)
 
-	Assert(t, ranHook, "hook did not run")
+	test.Assert(t, ranHook, "hook did not run")
 	debug.RemoveHook("pipe.walk2")
 
 	snapshots := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshots) > 0,
+	test.Assert(t, len(snapshots) > 0,
 		"no snapshots found in repo (%v)", datafile)
 
 	files := testRunLs(t, env.gopts, snapshots[0].String())
 
-	Assert(t, len(files) > 1, "snapshot is empty")
+	test.Assert(t, len(files) > 1, "snapshot is empty")
 }
 
 func includes(haystack []string, needle string) bool {
@@ -539,13 +538,13 @@ func TestBackupExclude(t *testing.T) {
 
 	for _, filename := range backupExcludeFilenames {
 		fp := filepath.Join(datadir, filename)
-		OK(t, os.MkdirAll(filepath.Dir(fp), 0755))
+		test.OK(t, os.MkdirAll(filepath.Dir(fp), 0755))
 
 		f, err := os.Create(fp)
-		OK(t, err)
+		test.OK(t, err)
 
 		fmt.Fprintf(f, filename)
-		OK(t, f.Close())
+		test.OK(t, f.Close())
 	}
 
 	snapshots := make(map[string]struct{})
@@ -555,23 +554,23 @@ func TestBackupExclude(t *testing.T) {
 	testRunBackup(t, []string{datadir}, opts, env.gopts)
 	snapshots, snapshotID := lastSnapshot(snapshots, loadSnapshotMap(t, env.gopts))
 	files := testRunLs(t, env.gopts, snapshotID)
-	Assert(t, includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")),
+	test.Assert(t, includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")),
 		"expected file %q in first snapshot, but it's not included", "foo.tar.gz")
 
 	opts.Excludes = []string{"*.tar.gz"}
 	testRunBackup(t, []string{datadir}, opts, env.gopts)
 	snapshots, snapshotID = lastSnapshot(snapshots, loadSnapshotMap(t, env.gopts))
 	files = testRunLs(t, env.gopts, snapshotID)
-	Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")),
+	test.Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")),
 		"expected file %q not in first snapshot, but it's included", "foo.tar.gz")
 
 	opts.Excludes = []string{"*.tar.gz", "private/secret"}
 	testRunBackup(t, []string{datadir}, opts, env.gopts)
 	_, snapshotID = lastSnapshot(snapshots, loadSnapshotMap(t, env.gopts))
 	files = testRunLs(t, env.gopts, snapshotID)
-	Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")),
+	test.Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")),
 		"expected file %q not in first snapshot, but it's included", "foo.tar.gz")
-	Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "private", "secret", "passwords.txt")),
+	test.Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "private", "secret", "passwords.txt")),
 		"expected file %q not in first snapshot, but it's included", "passwords.txt")
 }
 
@@ -612,7 +611,7 @@ func TestIncrementalBackup(t *testing.T) {
 	datadir := filepath.Join(env.base, "testdata")
 	testfile := filepath.Join(datadir, "testfile")
 
-	OK(t, appendRandomData(testfile, incrementalFirstWrite))
+	test.OK(t, appendRandomData(testfile, incrementalFirstWrite))
 
 	opts := BackupOptions{}
 
@@ -620,7 +619,7 @@ func TestIncrementalBackup(t *testing.T) {
 	testRunCheck(t, env.gopts)
 	stat1 := dirStats(env.repo)
 
-	OK(t, appendRandomData(testfile, incrementalSecondWrite))
+	test.OK(t, appendRandomData(testfile, incrementalSecondWrite))
 
 	testRunBackup(t, []string{datadir}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
@@ -630,7 +629,7 @@ func TestIncrementalBackup(t *testing.T) {
 	}
 	t.Logf("repository grown by %d bytes", stat2.size-stat1.size)
 
-	OK(t, appendRandomData(testfile, incrementalThirdWrite))
+	test.OK(t, appendRandomData(testfile, incrementalThirdWrite))
 
 	testRunBackup(t, []string{datadir}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
@@ -647,28 +646,28 @@ func TestBackupTags(t *testing.T) {
 
 	datafile := filepath.Join("testdata", "backup-data.tar.gz")
 	testRunInit(t, env.gopts)
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	opts := BackupOptions{}
 
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ := testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 0,
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 0,
 		"expected no tags, got %v", newest.Tags)
 
 	opts.Tags = []string{"NL"}
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ = testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL",
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL",
 		"expected one NL tag, got %v", newest.Tags)
 }
 
 func testRunTag(t testing.TB, opts TagOptions, gopts GlobalOptions) {
-	OK(t, runTag(opts, gopts, []string{}))
+	test.OK(t, runTag(opts, gopts, []string{}))
 }
 
 func TestTag(t *testing.T) {
@@ -677,68 +676,68 @@ func TestTag(t *testing.T) {
 
 	datafile := filepath.Join("testdata", "backup-data.tar.gz")
 	testRunInit(t, env.gopts)
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	testRunBackup(t, []string{env.testdata}, BackupOptions{}, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ := testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 0,
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 0,
 		"expected no tags, got %v", newest.Tags)
-	Assert(t, newest.Original == nil,
+	test.Assert(t, newest.Original == nil,
 		"expected original ID to be nil, got %v", newest.Original)
 	originalID := *newest.ID
 
 	testRunTag(t, TagOptions{SetTags: []string{"NL"}}, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ = testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL",
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL",
 		"set failed, expected one NL tag, got %v", newest.Tags)
-	Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
-	Assert(t, *newest.Original == originalID,
+	test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
+	test.Assert(t, *newest.Original == originalID,
 		"expected original ID to be set to the first snapshot id")
 
 	testRunTag(t, TagOptions{AddTags: []string{"CH"}}, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ = testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 2 && newest.Tags[0] == "NL" && newest.Tags[1] == "CH",
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 2 && newest.Tags[0] == "NL" && newest.Tags[1] == "CH",
 		"add failed, expected CH,NL tags, got %v", newest.Tags)
-	Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
-	Assert(t, *newest.Original == originalID,
+	test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
+	test.Assert(t, *newest.Original == originalID,
 		"expected original ID to be set to the first snapshot id")
 
 	testRunTag(t, TagOptions{RemoveTags: []string{"NL"}}, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ = testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "CH",
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "CH",
 		"remove failed, expected one CH tag, got %v", newest.Tags)
-	Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
-	Assert(t, *newest.Original == originalID,
+	test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
+	test.Assert(t, *newest.Original == originalID,
 		"expected original ID to be set to the first snapshot id")
 
 	testRunTag(t, TagOptions{AddTags: []string{"US", "RU"}}, env.gopts)
 	testRunTag(t, TagOptions{RemoveTags: []string{"CH", "US", "RU"}}, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ = testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 0,
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 0,
 		"expected no tags, got %v", newest.Tags)
-	Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
-	Assert(t, *newest.Original == originalID,
+	test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
+	test.Assert(t, *newest.Original == originalID,
 		"expected original ID to be set to the first snapshot id")
 
 	// Check special case of removing all tags.
 	testRunTag(t, TagOptions{SetTags: []string{""}}, env.gopts)
 	testRunCheck(t, env.gopts)
 	newest, _ = testRunSnapshots(t, env.gopts)
-	Assert(t, newest != nil, "expected a new backup, got nil")
-	Assert(t, len(newest.Tags) == 0,
+	test.Assert(t, newest != nil, "expected a new backup, got nil")
+	test.Assert(t, len(newest.Tags) == 0,
 		"expected no tags, got %v", newest.Tags)
-	Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
-	Assert(t, *newest.Original == originalID,
+	test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil")
+	test.Assert(t, *newest.Original == originalID,
 		"expected original ID to be set to the first snapshot id")
 }
 
@@ -750,7 +749,7 @@ func testRunKeyListOtherIDs(t testing.TB, gopts GlobalOptions) []string {
 		globalOptions.stdout = os.Stdout
 	}()
 
-	OK(t, runKey(gopts, []string{"list"}))
+	test.OK(t, runKey(gopts, []string{"list"}))
 
 	scanner := bufio.NewScanner(buf)
 	exp := regexp.MustCompile(`^ ([a-f0-9]+) `)
@@ -771,7 +770,7 @@ func testRunKeyAddNewKey(t testing.TB, newPassword string, gopts GlobalOptions)
 		testKeyNewPassword = ""
 	}()
 
-	OK(t, runKey(gopts, []string{"add"}))
+	test.OK(t, runKey(gopts, []string{"add"}))
 }
 
 func testRunKeyPasswd(t testing.TB, newPassword string, gopts GlobalOptions) {
@@ -780,13 +779,13 @@ func testRunKeyPasswd(t testing.TB, newPassword string, gopts GlobalOptions) {
 		testKeyNewPassword = ""
 	}()
 
-	OK(t, runKey(gopts, []string{"passwd"}))
+	test.OK(t, runKey(gopts, []string{"passwd"}))
 }
 
 func testRunKeyRemove(t testing.TB, gopts GlobalOptions, IDs []string) {
 	t.Logf("remove %d keys: %q\n", len(IDs), IDs)
 	for _, id := range IDs {
-		OK(t, runKey(gopts, []string{"remove", id}))
+		test.OK(t, runKey(gopts, []string{"remove", id}))
 	}
 }
 
@@ -814,7 +813,7 @@ func TestKeyAddRemove(t *testing.T) {
 
 	env.gopts.password = passwordList[len(passwordList)-1]
 	t.Logf("testing access with last password %q\n", env.gopts.password)
-	OK(t, runKey(env.gopts, []string{"list"}))
+	test.OK(t, runKey(env.gopts, []string{"list"}))
 	testRunCheck(t, env.gopts)
 }
 
@@ -847,10 +846,10 @@ func TestRestoreFilter(t *testing.T) {
 
 	testRunInit(t, env.gopts)
 
-	for _, test := range testfiles {
-		p := filepath.Join(env.testdata, test.name)
-		OK(t, os.MkdirAll(filepath.Dir(p), 0755))
-		OK(t, appendRandomData(p, test.size))
+	for _, testFile := range testfiles {
+		p := filepath.Join(env.testdata, testFile.name)
+		test.OK(t, os.MkdirAll(filepath.Dir(p), 0755))
+		test.OK(t, appendRandomData(p, testFile.size))
 	}
 
 	opts := BackupOptions{}
@@ -862,20 +861,20 @@ func TestRestoreFilter(t *testing.T) {
 
 	// no restore filter should restore all files
 	testRunRestore(t, env.gopts, filepath.Join(env.base, "restore0"), snapshotID)
-	for _, test := range testfiles {
-		OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", test.name), int64(test.size)))
+	for _, testFile := range testfiles {
+		test.OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", testFile.name), int64(testFile.size)))
 	}
 
 	for i, pat := range []string{"*.c", "*.exe", "*", "*file3*"} {
 		base := filepath.Join(env.base, fmt.Sprintf("restore%d", i+1))
 		testRunRestoreExcludes(t, env.gopts, base, snapshotID, []string{pat})
-		for _, test := range testfiles {
-			err := testFileSize(filepath.Join(base, "testdata", test.name), int64(test.size))
-			if ok, _ := filter.Match(pat, filepath.Base(test.name)); !ok {
-				OK(t, err)
+		for _, testFile := range testfiles {
+			err := testFileSize(filepath.Join(base, "testdata", testFile.name), int64(testFile.size))
+			if ok, _ := filter.Match(pat, filepath.Base(testFile.name)); !ok {
+				test.OK(t, err)
 			} else {
-				Assert(t, os.IsNotExist(errors.Cause(err)),
-					"expected %v to not exist in restore step %v, but it exists, err %v", test.name, i+1, err)
+				test.Assert(t, os.IsNotExist(errors.Cause(err)),
+					"expected %v to not exist in restore step %v, but it exists, err %v", testFile.name, i+1, err)
 			}
 		}
 	}
@@ -889,8 +888,8 @@ func TestRestore(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		p := filepath.Join(env.testdata, fmt.Sprintf("foo/bar/testfile%v", i))
-		OK(t, os.MkdirAll(filepath.Dir(p), 0755))
-		OK(t, appendRandomData(p, uint(mrand.Intn(5<<21))))
+		test.OK(t, os.MkdirAll(filepath.Dir(p), 0755))
+		test.OK(t, appendRandomData(p, uint(mrand.Intn(5<<21))))
 	}
 
 	opts := BackupOptions{}
@@ -902,7 +901,7 @@ func TestRestore(t *testing.T) {
 	restoredir := filepath.Join(env.base, "restore")
 	testRunRestoreLatest(t, env.gopts, restoredir, nil, "")
 
-	Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, filepath.Base(env.testdata))),
+	test.Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, filepath.Base(env.testdata))),
 		"directories are not equal")
 }
 
@@ -913,8 +912,8 @@ func TestRestoreLatest(t *testing.T) {
 	testRunInit(t, env.gopts)
 
 	p := filepath.Join(env.testdata, "testfile.c")
-	OK(t, os.MkdirAll(filepath.Dir(p), 0755))
-	OK(t, appendRandomData(p, 100))
+	test.OK(t, os.MkdirAll(filepath.Dir(p), 0755))
+	test.OK(t, appendRandomData(p, 100))
 
 	opts := BackupOptions{}
 
@@ -922,24 +921,24 @@ func TestRestoreLatest(t *testing.T) {
 	testRunCheck(t, env.gopts)
 
 	os.Remove(p)
-	OK(t, appendRandomData(p, 101))
+	test.OK(t, appendRandomData(p, 101))
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 
 	// Restore latest without any filters
 	testRunRestoreLatest(t, env.gopts, filepath.Join(env.base, "restore0"), nil, "")
-	OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", "testfile.c"), int64(101)))
+	test.OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", "testfile.c"), int64(101)))
 
 	// Setup test files in different directories backed up in different snapshots
 	p1 := filepath.Join(env.testdata, "p1/testfile.c")
-	OK(t, os.MkdirAll(filepath.Dir(p1), 0755))
-	OK(t, appendRandomData(p1, 102))
+	test.OK(t, os.MkdirAll(filepath.Dir(p1), 0755))
+	test.OK(t, appendRandomData(p1, 102))
 	testRunBackup(t, []string{filepath.Dir(p1)}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 
 	p2 := filepath.Join(env.testdata, "p2/testfile.c")
-	OK(t, os.MkdirAll(filepath.Dir(p2), 0755))
-	OK(t, appendRandomData(p2, 103))
+	test.OK(t, os.MkdirAll(filepath.Dir(p2), 0755))
+	test.OK(t, appendRandomData(p2, 103))
 	testRunBackup(t, []string{filepath.Dir(p2)}, opts, env.gopts)
 	testRunCheck(t, env.gopts)
 
@@ -947,16 +946,16 @@ func TestRestoreLatest(t *testing.T) {
 	p2rAbs := filepath.Join(env.base, "restore2", "p2/testfile.c")
 
 	testRunRestoreLatest(t, env.gopts, filepath.Join(env.base, "restore1"), []string{filepath.Dir(p1)}, "")
-	OK(t, testFileSize(p1rAbs, int64(102)))
+	test.OK(t, testFileSize(p1rAbs, int64(102)))
 	if _, err := os.Stat(p2rAbs); os.IsNotExist(errors.Cause(err)) {
-		Assert(t, os.IsNotExist(errors.Cause(err)),
+		test.Assert(t, os.IsNotExist(errors.Cause(err)),
 			"expected %v to not exist in restore, but it exists, err %v", p2rAbs, err)
 	}
 
 	testRunRestoreLatest(t, env.gopts, filepath.Join(env.base, "restore2"), []string{filepath.Dir(p2)}, "")
-	OK(t, testFileSize(p2rAbs, int64(103)))
+	test.OK(t, testFileSize(p2rAbs, int64(103)))
 	if _, err := os.Stat(p1rAbs); os.IsNotExist(errors.Cause(err)) {
-		Assert(t, os.IsNotExist(errors.Cause(err)),
+		test.Assert(t, os.IsNotExist(errors.Cause(err)),
 			"expected %v to not exist in restore, but it exists, err %v", p1rAbs, err)
 	}
 }
@@ -966,10 +965,10 @@ func TestRestoreWithPermissionFailure(t *testing.T) {
 	defer cleanup()
 
 	datafile := filepath.Join("testdata", "repo-restore-permissions-test.tar.gz")
-	SetupTarTestFixture(t, env.base, datafile)
+	test.SetupTarTestFixture(t, env.base, datafile)
 
 	snapshots := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshots) > 0,
+	test.Assert(t, len(snapshots) > 0,
 		"no snapshots found in repo (%v)", datafile)
 
 	globalOptions.stderr = ioutil.Discard
@@ -984,9 +983,9 @@ func TestRestoreWithPermissionFailure(t *testing.T) {
 	files := testRunLs(t, env.gopts, snapshots[0].String())
 	for _, filename := range files {
 		fi, err := os.Lstat(filepath.Join(env.base, "restore", filename))
-		OK(t, err)
+		test.OK(t, err)
 
-		Assert(t, !isFile(fi) || fi.Size() > 0,
+		test.Assert(t, !isFile(fi) || fi.Size() > 0,
 			"file %v restored, but filesize is 0", filename)
 	}
 }
@@ -1007,9 +1006,9 @@ func TestRestoreNoMetadataOnIgnoredIntermediateDirs(t *testing.T) {
 	testRunInit(t, env.gopts)
 
 	p := filepath.Join(env.testdata, "subdir1", "subdir2", "subdir3", "file.ext")
-	OK(t, os.MkdirAll(filepath.Dir(p), 0755))
-	OK(t, appendRandomData(p, 200))
-	OK(t, setZeroModTime(filepath.Join(env.testdata, "subdir1", "subdir2")))
+	test.OK(t, os.MkdirAll(filepath.Dir(p), 0755))
+	test.OK(t, appendRandomData(p, 200))
+	test.OK(t, setZeroModTime(filepath.Join(env.testdata, "subdir1", "subdir2")))
 
 	opts := BackupOptions{}
 
@@ -1025,9 +1024,9 @@ func TestRestoreNoMetadataOnIgnoredIntermediateDirs(t *testing.T) {
 
 	f1 := filepath.Join(env.base, "restore0", "testdata", "subdir1", "subdir2")
 	fi, err := os.Stat(f1)
-	OK(t, err)
+	test.OK(t, err)
 
-	Assert(t, fi.ModTime() != time.Unix(0, 0),
+	test.Assert(t, fi.ModTime() != time.Unix(0, 0),
 		"meta data of intermediate directory has been restore although it was ignored")
 
 	// restore with filter "*", this should restore meta data on everything.
@@ -1035,9 +1034,9 @@ func TestRestoreNoMetadataOnIgnoredIntermediateDirs(t *testing.T) {
 
 	f2 := filepath.Join(env.base, "restore1", "testdata", "subdir1", "subdir2")
 	fi, err = os.Stat(f2)
-	OK(t, err)
+	test.OK(t, err)
 
-	Assert(t, fi.ModTime() == time.Unix(0, 0),
+	test.Assert(t, fi.ModTime() == time.Unix(0, 0),
 		"meta data of intermediate directory hasn't been restore")
 }
 
@@ -1047,7 +1046,7 @@ func TestFind(t *testing.T) {
 
 	datafile := filepath.Join("testdata", "backup-data.tar.gz")
 	testRunInit(t, env.gopts)
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	opts := BackupOptions{}
 
@@ -1055,15 +1054,15 @@ func TestFind(t *testing.T) {
 	testRunCheck(t, env.gopts)
 
 	results := testRunFind(t, false, env.gopts, "unexistingfile")
-	Assert(t, len(results) == 0, "unexisting file found in repo (%v)", datafile)
+	test.Assert(t, len(results) == 0, "unexisting file found in repo (%v)", datafile)
 
 	results = testRunFind(t, false, env.gopts, "testfile")
 	lines := strings.Split(string(results), "\n")
-	Assert(t, len(lines) == 2, "expected one file found in repo (%v)", datafile)
+	test.Assert(t, len(lines) == 2, "expected one file found in repo (%v)", datafile)
 
 	results = testRunFind(t, false, env.gopts, "testfile*")
 	lines = strings.Split(string(results), "\n")
-	Assert(t, len(lines) == 4, "expected three files found in repo (%v)", datafile)
+	test.Assert(t, len(lines) == 4, "expected three files found in repo (%v)", datafile)
 }
 
 type testMatch struct {
@@ -1087,7 +1086,7 @@ func TestFindJSON(t *testing.T) {
 
 	datafile := filepath.Join("testdata", "backup-data.tar.gz")
 	testRunInit(t, env.gopts)
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	opts := BackupOptions{}
 
@@ -1096,20 +1095,20 @@ func TestFindJSON(t *testing.T) {
 
 	results := testRunFind(t, true, env.gopts, "unexistingfile")
 	matches := []testMatches{}
-	OK(t, json.Unmarshal(results, &matches))
-	Assert(t, len(matches) == 0, "expected no match in repo (%v)", datafile)
+	test.OK(t, json.Unmarshal(results, &matches))
+	test.Assert(t, len(matches) == 0, "expected no match in repo (%v)", datafile)
 
 	results = testRunFind(t, true, env.gopts, "testfile")
-	OK(t, json.Unmarshal(results, &matches))
-	Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile)
-	Assert(t, len(matches[0].Matches) == 1, "expected a single file to match (%v)", datafile)
-	Assert(t, matches[0].Hits == 1, "expected hits to show 1 match (%v)", datafile)
+	test.OK(t, json.Unmarshal(results, &matches))
+	test.Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile)
+	test.Assert(t, len(matches[0].Matches) == 1, "expected a single file to match (%v)", datafile)
+	test.Assert(t, matches[0].Hits == 1, "expected hits to show 1 match (%v)", datafile)
 
 	results = testRunFind(t, true, env.gopts, "testfile*")
-	OK(t, json.Unmarshal(results, &matches))
-	Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile)
-	Assert(t, len(matches[0].Matches) == 3, "expected 3 files to match (%v)", datafile)
-	Assert(t, matches[0].Hits == 3, "expected hits to show 3 matches (%v)", datafile)
+	test.OK(t, json.Unmarshal(results, &matches))
+	test.Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile)
+	test.Assert(t, len(matches[0].Matches) == 3, "expected 3 files to match (%v)", datafile)
+	test.Assert(t, matches[0].Hits == 3, "expected hits to show 3 matches (%v)", datafile)
 }
 
 func TestRebuildIndex(t *testing.T) {
@@ -1117,7 +1116,7 @@ func TestRebuildIndex(t *testing.T) {
 	defer cleanup()
 
 	datafile := filepath.Join("..", "..", "internal", "checker", "testdata", "duplicate-packs-in-index-test-repo.tar.gz")
-	SetupTarTestFixture(t, env.base, datafile)
+	test.SetupTarTestFixture(t, env.base, datafile)
 
 	out, err := testRunCheckOutput(env.gopts)
 	if !strings.Contains(out, "contained in several indexes") {
@@ -1154,7 +1153,7 @@ func TestCheckRestoreNoLock(t *testing.T) {
 	defer cleanup()
 
 	datafile := filepath.Join("testdata", "small-repo.tar.gz")
-	SetupTarTestFixture(t, env.base, datafile)
+	test.SetupTarTestFixture(t, env.base, datafile)
 
 	err := filepath.Walk(env.repo, func(p string, fi os.FileInfo, e error) error {
 		if e != nil {
@@ -1162,7 +1161,7 @@ func TestCheckRestoreNoLock(t *testing.T) {
 		}
 		return os.Chmod(p, fi.Mode() & ^(os.FileMode(0222)))
 	})
-	OK(t, err)
+	test.OK(t, err)
 
 	env.gopts.NoLock = true
 
@@ -1186,24 +1185,24 @@ func TestPrune(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
 	testRunInit(t, env.gopts)
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 	opts := BackupOptions{}
 
 	testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0")}, opts, env.gopts)
 	firstSnapshot := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(firstSnapshot) == 1,
+	test.Assert(t, len(firstSnapshot) == 1,
 		"expected one snapshot, got %v", firstSnapshot)
 
 	testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0", "2")}, opts, env.gopts)
 	testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0", "3")}, opts, env.gopts)
 
 	snapshotIDs := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 3,
+	test.Assert(t, len(snapshotIDs) == 3,
 		"expected 3 snapshot, got %v", snapshotIDs)
 
 	testRunForget(t, env.gopts, firstSnapshot[0].String())
@@ -1222,12 +1221,12 @@ func TestHardLink(t *testing.T) {
 		t.Skipf("unable to find data file %q, skipping", datafile)
 		return
 	}
-	OK(t, err)
-	OK(t, fd.Close())
+	test.OK(t, err)
+	test.OK(t, fd.Close())
 
 	testRunInit(t, env.gopts)
 
-	SetupTarTestFixture(t, env.testdata, datafile)
+	test.SetupTarTestFixture(t, env.testdata, datafile)
 
 	linkTests := createFileSetPerHardlink(env.testdata)
 
@@ -1236,7 +1235,7 @@ func TestHardLink(t *testing.T) {
 	// first backup
 	testRunBackup(t, []string{env.testdata}, opts, env.gopts)
 	snapshotIDs := testRunList(t, "snapshots", env.gopts)
-	Assert(t, len(snapshotIDs) == 1,
+	test.Assert(t, len(snapshotIDs) == 1,
 		"expected one snapshot, got %v", snapshotIDs)
 
 	testRunCheck(t, env.gopts)
@@ -1246,11 +1245,11 @@ func TestHardLink(t *testing.T) {
 		restoredir := filepath.Join(env.base, fmt.Sprintf("restore%d", i))
 		t.Logf("restoring snapshot %v to %v", snapshotID.Str(), restoredir)
 		testRunRestore(t, env.gopts, restoredir, snapshotIDs[0])
-		Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")),
+		test.Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")),
 			"directories are not equal")
 
 		linkResults := createFileSetPerHardlink(filepath.Join(restoredir, "testdata"))
-		Assert(t, linksEqual(linkTests, linkResults),
+		test.Assert(t, linksEqual(linkTests, linkResults),
 			"links are not equal")
 	}
 
diff --git a/cmd/restic/local_layout_test.go b/cmd/restic/local_layout_test.go
index 4d22342ee..c76112e00 100644
--- a/cmd/restic/local_layout_test.go
+++ b/cmd/restic/local_layout_test.go
@@ -4,7 +4,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestRestoreLocalLayout(t *testing.T) {
@@ -24,7 +24,7 @@ func TestRestoreLocalLayout(t *testing.T) {
 	for _, test := range tests {
 		datafile := filepath.Join("..", "..", "internal", "backend", "testdata", test.filename)
 
-		SetupTarTestFixture(t, env.base, datafile)
+		rtest.SetupTarTestFixture(t, env.base, datafile)
 
 		env.gopts.extended["local.layout"] = test.layout
 
@@ -35,7 +35,7 @@ func TestRestoreLocalLayout(t *testing.T) {
 		target := filepath.Join(env.base, "restore")
 		testRunRestoreLatest(t, env.gopts, target, nil, "")
 
-		RemoveAll(t, filepath.Join(env.base, "repo"))
-		RemoveAll(t, target)
+		rtest.RemoveAll(t, filepath.Join(env.base, "repo"))
+		rtest.RemoveAll(t, target)
 	}
 }
diff --git a/internal/archiver/archiver_test.go b/internal/archiver/archiver_test.go
index cc29ae330..01e9d9e74 100644
--- a/internal/archiver/archiver_test.go
+++ b/internal/archiver/archiver_test.go
@@ -15,7 +15,7 @@ import (
 	"github.com/restic/restic/internal/crypto"
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 
 	"github.com/restic/restic/internal/errors"
 
@@ -40,14 +40,14 @@ func benchmarkChunkEncrypt(b testing.TB, buf, buf2 []byte, rd Rdr, key *crypto.K
 			break
 		}
 
-		OK(b, err)
+		rtest.OK(b, err)
 
 		// reduce length of buf
-		Assert(b, uint(len(chunk.Data)) == chunk.Length,
+		rtest.Assert(b, uint(len(chunk.Data)) == chunk.Length,
 			"invalid length: got %d, expected %d", len(chunk.Data), chunk.Length)
 
 		_, err = key.Encrypt(buf2, chunk.Data)
-		OK(b, err)
+		rtest.OK(b, err)
 	}
 }
 
@@ -55,7 +55,7 @@ func BenchmarkChunkEncrypt(b *testing.B) {
 	repo, cleanup := repository.TestRepository(b)
 	defer cleanup()
 
-	data := Random(23, 10<<20) // 10MiB
+	data := rtest.Random(23, 10<<20) // 10MiB
 	rd := bytes.NewReader(data)
 
 	buf := make([]byte, chunker.MaxSize)
@@ -87,7 +87,7 @@ func BenchmarkChunkEncryptParallel(b *testing.B) {
 	repo, cleanup := repository.TestRepository(b)
 	defer cleanup()
 
-	data := Random(23, 10<<20) // 10MiB
+	data := rtest.Random(23, 10<<20) // 10MiB
 
 	buf := make([]byte, chunker.MaxSize)
 
@@ -108,14 +108,14 @@ func archiveDirectory(b testing.TB) {
 
 	arch := archiver.New(repo)
 
-	_, id, err := arch.Snapshot(context.TODO(), nil, []string{BenchArchiveDirectory}, nil, "localhost", nil, time.Now())
-	OK(b, err)
+	_, id, err := arch.Snapshot(context.TODO(), nil, []string{rtest.BenchArchiveDirectory}, nil, "localhost", nil, time.Now())
+	rtest.OK(b, err)
 
 	b.Logf("snapshot archived as %v", id)
 }
 
 func TestArchiveDirectory(t *testing.T) {
-	if BenchArchiveDirectory == "" {
+	if rtest.BenchArchiveDirectory == "" {
 		t.Skip("benchdir not set, skipping TestArchiveDirectory")
 	}
 
@@ -123,7 +123,7 @@ func TestArchiveDirectory(t *testing.T) {
 }
 
 func BenchmarkArchiveDirectory(b *testing.B) {
-	if BenchArchiveDirectory == "" {
+	if rtest.BenchArchiveDirectory == "" {
 		b.Skip("benchdir not set, skipping BenchmarkArchiveDirectory")
 	}
 
@@ -144,7 +144,7 @@ func archiveWithDedup(t testing.TB) {
 	repo, cleanup := repository.TestRepository(t)
 	defer cleanup()
 
-	if BenchArchiveDirectory == "" {
+	if rtest.BenchArchiveDirectory == "" {
 		t.Skip("benchdir not set, skipping TestArchiverDedup")
 	}
 
@@ -155,7 +155,7 @@ func archiveWithDedup(t testing.TB) {
 	}
 
 	// archive a few files
-	sn := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil)
+	sn := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil)
 	t.Logf("archived snapshot %v", sn.ID().Str())
 
 	// get archive stats
@@ -166,7 +166,7 @@ func archiveWithDedup(t testing.TB) {
 		cnt.before.packs, cnt.before.dataBlobs, cnt.before.treeBlobs)
 
 	// archive the same files again, without parent snapshot
-	sn2 := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil)
+	sn2 := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil)
 	t.Logf("archived snapshot %v", sn2.ID().Str())
 
 	// get archive stats again
@@ -183,7 +183,7 @@ func archiveWithDedup(t testing.TB) {
 	}
 
 	// archive the same files again, with a parent snapshot
-	sn3 := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, sn2.ID())
+	sn3 := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, sn2.ID())
 	t.Logf("archived snapshot %v, parent %v", sn3.ID().Str(), sn2.ID().Str())
 
 	// get archive stats again
@@ -246,18 +246,18 @@ func testParallelSaveWithDuplication(t *testing.T, seed int) {
 	}
 
 	for _, errChan := range errChannels {
-		OK(t, <-errChan)
+		rtest.OK(t, <-errChan)
 	}
 
-	OK(t, repo.Flush())
-	OK(t, repo.SaveIndex(context.TODO()))
+	rtest.OK(t, repo.Flush())
+	rtest.OK(t, repo.SaveIndex(context.TODO()))
 
 	chkr := createAndInitChecker(t, repo)
 	assertNoUnreferencedPacks(t, chkr)
 }
 
 func getRandomData(seed int, size int) []chunker.Chunk {
-	buf := Random(seed, size)
+	buf := rtest.Random(seed, size)
 	var chunks []chunker.Chunk
 	chunker := chunker.New(bytes.NewReader(buf), testPol)
 
@@ -292,7 +292,7 @@ func assertNoUnreferencedPacks(t *testing.T, chkr *checker.Checker) {
 	go chkr.Packs(context.TODO(), errChan)
 
 	for err := range errChan {
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 }
 
@@ -341,26 +341,26 @@ func TestArchiveNameCollision(t *testing.T) {
 	repo, cleanup := repository.TestRepository(t)
 	defer cleanup()
 
-	dir, cleanup := TempDir(t)
+	dir, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	root := filepath.Join(dir, "root")
-	OK(t, os.MkdirAll(root, 0755))
+	rtest.OK(t, os.MkdirAll(root, 0755))
 
-	OK(t, ioutil.WriteFile(filepath.Join(dir, "testfile"), []byte("testfile1"), 0644))
-	OK(t, ioutil.WriteFile(filepath.Join(dir, "root", "testfile"), []byte("testfile2"), 0644))
+	rtest.OK(t, ioutil.WriteFile(filepath.Join(dir, "testfile"), []byte("testfile1"), 0644))
+	rtest.OK(t, ioutil.WriteFile(filepath.Join(dir, "root", "testfile"), []byte("testfile2"), 0644))
 
 	defer chdir(t, root)()
 
 	arch := archiver.New(repo)
 
 	sn, id, err := arch.Snapshot(context.TODO(), nil, []string{"testfile", filepath.Join("..", "testfile")}, nil, "localhost", nil, time.Now())
-	OK(t, err)
+	rtest.OK(t, err)
 
 	t.Logf("snapshot archived as %v", id)
 
 	tree, err := repo.LoadTree(context.TODO(), *sn.Tree)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	if len(tree.Nodes) != 2 {
 		t.Fatalf("tree has %d nodes, wanted 2: %v", len(tree.Nodes), tree.Nodes)
diff --git a/internal/backend/azure/azure_test.go b/internal/backend/azure/azure_test.go
index 4f59e3be9..326b9152f 100644
--- a/internal/backend/azure/azure_test.go
+++ b/internal/backend/azure/azure_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/errors"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func newAzureTestSuite(t testing.TB) *test.Suite {
@@ -81,7 +81,7 @@ func newAzureTestSuite(t testing.TB) *test.Suite {
 func TestBackendAzure(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/azure.TestBackendAzure")
+			rtest.SkipDisallowed(t, "restic/backend/azure.TestBackendAzure")
 		}
 	}()
 
diff --git a/internal/backend/b2/b2_test.go b/internal/backend/b2/b2_test.go
index 7fe90b0a0..9c5c57455 100644
--- a/internal/backend/b2/b2_test.go
+++ b/internal/backend/b2/b2_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/restic"
 
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func newB2TestSuite(t testing.TB) *test.Suite {
@@ -83,7 +83,7 @@ func testVars(t testing.TB) {
 func TestBackendB2(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/b2.TestBackendB2")
+			rtest.SkipDisallowed(t, "restic/backend/b2.TestBackendB2")
 		}
 	}()
 
diff --git a/internal/backend/gs/gs_test.go b/internal/backend/gs/gs_test.go
index f7b412e5d..739aaacf3 100644
--- a/internal/backend/gs/gs_test.go
+++ b/internal/backend/gs/gs_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/errors"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func newGSTestSuite(t testing.TB) *test.Suite {
@@ -81,7 +81,7 @@ func newGSTestSuite(t testing.TB) *test.Suite {
 func TestBackendGS(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/gs.TestBackendGS")
+			rtest.SkipDisallowed(t, "restic/backend/gs.TestBackendGS")
 		}
 	}()
 
diff --git a/internal/backend/layout_test.go b/internal/backend/layout_test.go
index 35aa4bcce..0c52b32bc 100644
--- a/internal/backend/layout_test.go
+++ b/internal/backend/layout_test.go
@@ -9,11 +9,11 @@ import (
 	"testing"
 
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestDefaultLayout(t *testing.T) {
-	tempdir, cleanup := TempDir(t)
+	tempdir, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -140,7 +140,7 @@ func TestDefaultLayout(t *testing.T) {
 }
 
 func TestRESTLayout(t *testing.T) {
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -286,7 +286,7 @@ func TestRESTLayoutURLs(t *testing.T) {
 }
 
 func TestS3LegacyLayout(t *testing.T) {
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -354,7 +354,7 @@ func TestS3LegacyLayout(t *testing.T) {
 }
 
 func TestDetectLayout(t *testing.T) {
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -369,7 +369,7 @@ func TestDetectLayout(t *testing.T) {
 	for _, test := range tests {
 		for _, fs := range []Filesystem{fs, nil} {
 			t.Run(fmt.Sprintf("%v/fs-%T", test.filename, fs), func(t *testing.T) {
-				SetupTarTestFixture(t, path, filepath.Join("testdata", test.filename))
+				rtest.SetupTarTestFixture(t, path, filepath.Join("testdata", test.filename))
 
 				layout, err := DetectLayout(fs, filepath.Join(path, "repo"))
 				if err != nil {
@@ -385,14 +385,14 @@ func TestDetectLayout(t *testing.T) {
 					t.Fatalf("want layout %v, got %v", test.want, layoutName)
 				}
 
-				RemoveAll(t, filepath.Join(path, "repo"))
+				rtest.RemoveAll(t, filepath.Join(path, "repo"))
 			})
 		}
 	}
 }
 
 func TestParseLayout(t *testing.T) {
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -405,7 +405,7 @@ func TestParseLayout(t *testing.T) {
 		{"", "", "*backend.DefaultLayout"},
 	}
 
-	SetupTarTestFixture(t, path, filepath.Join("testdata", "repo-layout-default.tar.gz"))
+	rtest.SetupTarTestFixture(t, path, filepath.Join("testdata", "repo-layout-default.tar.gz"))
 
 	for _, test := range tests {
 		t.Run(test.layoutName, func(t *testing.T) {
@@ -432,7 +432,7 @@ func TestParseLayout(t *testing.T) {
 }
 
 func TestParseLayoutInvalid(t *testing.T) {
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var invalidNames = []string{
diff --git a/internal/backend/local/layout_test.go b/internal/backend/local/layout_test.go
index 1b2e342c7..05eba96f0 100644
--- a/internal/backend/local/layout_test.go
+++ b/internal/backend/local/layout_test.go
@@ -6,11 +6,11 @@ import (
 	"testing"
 
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestLayout(t *testing.T) {
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -33,7 +33,7 @@ func TestLayout(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.filename, func(t *testing.T) {
-			SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename))
+			rtest.SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename))
 
 			repo := filepath.Join(path, "repo")
 			be, err := Open(Config{
@@ -75,7 +75,7 @@ func TestLayout(t *testing.T) {
 				t.Errorf("Close() returned error %v", err)
 			}
 
-			RemoveAll(t, filepath.Join(path, "repo"))
+			rtest.RemoveAll(t, filepath.Join(path, "repo"))
 		})
 	}
 }
diff --git a/internal/backend/local/local_test.go b/internal/backend/local/local_test.go
index e5b1e2533..4ca3fdb71 100644
--- a/internal/backend/local/local_test.go
+++ b/internal/backend/local/local_test.go
@@ -9,14 +9,14 @@ import (
 	"github.com/restic/restic/internal/backend/local"
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func newTestSuite(t testing.TB) *test.Suite {
 	return &test.Suite{
 		// NewConfig returns a config for a new temporary backend that will be used in tests.
 		NewConfig: func() (interface{}, error) {
-			dir, err := ioutil.TempDir(TestTempDir, "restic-test-local-")
+			dir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-local-")
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -44,11 +44,11 @@ func newTestSuite(t testing.TB) *test.Suite {
 		// CleanupFn removes data created during the tests.
 		Cleanup: func(config interface{}) error {
 			cfg := config.(local.Config)
-			if !TestCleanupTempDirs {
+			if !rtest.TestCleanupTempDirs {
 				t.Logf("leaving test backend dir at %v", cfg.Path)
 			}
 
-			RemoveAll(t, cfg.Path)
+			rtest.RemoveAll(t, cfg.Path)
 			return nil
 		},
 	}
@@ -119,7 +119,7 @@ func removeAll(t testing.TB, dir string) {
 }
 
 func TestOpenNotExistingDirectory(t *testing.T) {
-	dir, cleanup := TempDir(t)
+	dir, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	// local.Open must not create any files dirs in the repo
diff --git a/internal/backend/rest/rest_test.go b/internal/backend/rest/rest_test.go
index 314a5c32b..f6fbafbd6 100644
--- a/internal/backend/rest/rest_test.go
+++ b/internal/backend/rest/rest_test.go
@@ -13,7 +13,7 @@ import (
 	"github.com/restic/restic/internal/backend/rest"
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func runRESTServer(ctx context.Context, t testing.TB, dir string) func() {
@@ -64,7 +64,7 @@ func newTestSuite(ctx context.Context, t testing.TB) *test.Suite {
 	return &test.Suite{
 		// NewConfig returns a config for a new temporary backend that will be used in tests.
 		NewConfig: func() (interface{}, error) {
-			dir, err := ioutil.TempDir(TestTempDir, "restic-test-rest-")
+			dir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-rest-")
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -103,14 +103,14 @@ func newTestSuite(ctx context.Context, t testing.TB) *test.Suite {
 func TestBackendREST(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/rest.TestBackendREST")
+			rtest.SkipDisallowed(t, "restic/backend/rest.TestBackendREST")
 		}
 	}()
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	dir, cleanup := TempDir(t)
+	dir, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	cleanup = runRESTServer(ctx, t, dir)
@@ -123,7 +123,7 @@ func BenchmarkBackendREST(t *testing.B) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	dir, cleanup := TempDir(t)
+	dir, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	cleanup = runRESTServer(ctx, t, dir)
diff --git a/internal/backend/s3/s3_test.go b/internal/backend/s3/s3_test.go
index 19927b6ac..3cc20cc72 100644
--- a/internal/backend/s3/s3_test.go
+++ b/internal/backend/s3/s3_test.go
@@ -17,7 +17,7 @@ import (
 	"github.com/restic/restic/internal/backend/s3"
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func mkdir(t testing.TB, dir string) {
@@ -124,7 +124,7 @@ func newMinioTestSuite(ctx context.Context, t testing.TB) *test.Suite {
 		NewConfig: func() (interface{}, error) {
 			cfg := MinioTestConfig{}
 
-			cfg.tempdir, cfg.removeTempdir = TempDir(t)
+			cfg.tempdir, cfg.removeTempdir = rtest.TempDir(t)
 			key, secret := newRandomCredentials(t)
 			cfg.stopServer = runMinio(ctx, t, cfg.tempdir, key, secret)
 
@@ -182,7 +182,7 @@ func newMinioTestSuite(ctx context.Context, t testing.TB) *test.Suite {
 func TestBackendMinio(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/s3.TestBackendMinio")
+			rtest.SkipDisallowed(t, "restic/backend/s3.TestBackendMinio")
 		}
 	}()
 
@@ -280,7 +280,7 @@ func newS3TestSuite(t testing.TB) *test.Suite {
 func TestBackendS3(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/s3.TestBackendS3")
+			rtest.SkipDisallowed(t, "restic/backend/s3.TestBackendS3")
 		}
 	}()
 
diff --git a/internal/backend/sftp/layout_test.go b/internal/backend/sftp/layout_test.go
index 9a5878e0d..0a9e9eae9 100644
--- a/internal/backend/sftp/layout_test.go
+++ b/internal/backend/sftp/layout_test.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/restic/restic/internal/backend/sftp"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestLayout(t *testing.T) {
@@ -16,7 +16,7 @@ func TestLayout(t *testing.T) {
 		t.Skip("sftp server binary not available")
 	}
 
-	path, cleanup := TempDir(t)
+	path, cleanup := rtest.TempDir(t)
 	defer cleanup()
 
 	var tests = []struct {
@@ -39,7 +39,7 @@ func TestLayout(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.filename, func(t *testing.T) {
-			SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename))
+			rtest.SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename))
 
 			repo := filepath.Join(path, "repo")
 			be, err := sftp.Open(sftp.Config{
@@ -82,7 +82,7 @@ func TestLayout(t *testing.T) {
 				t.Errorf("Close() returned error %v", err)
 			}
 
-			RemoveAll(t, filepath.Join(path, "repo"))
+			rtest.RemoveAll(t, filepath.Join(path, "repo"))
 		})
 	}
 }
diff --git a/internal/backend/sftp/sftp_test.go b/internal/backend/sftp/sftp_test.go
index 56d9f9172..513d6e7d3 100644
--- a/internal/backend/sftp/sftp_test.go
+++ b/internal/backend/sftp/sftp_test.go
@@ -12,12 +12,11 @@ import (
 	"github.com/restic/restic/internal/backend/test"
 	"github.com/restic/restic/internal/errors"
 	"github.com/restic/restic/internal/restic"
-
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func findSFTPServerBinary() string {
-	for _, dir := range strings.Split(TestSFTPPath, ":") {
+	for _, dir := range strings.Split(rtest.TestSFTPPath, ":") {
 		testpath := filepath.Join(dir, "sftp-server")
 		_, err := os.Stat(testpath)
 		if !os.IsNotExist(errors.Cause(err)) {
@@ -34,7 +33,7 @@ func newTestSuite(t testing.TB) *test.Suite {
 	return &test.Suite{
 		// NewConfig returns a config for a new temporary backend that will be used in tests.
 		NewConfig: func() (interface{}, error) {
-			dir, err := ioutil.TempDir(TestTempDir, "restic-test-sftp-")
+			dir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-sftp-")
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -63,11 +62,11 @@ func newTestSuite(t testing.TB) *test.Suite {
 		// CleanupFn removes data created during the tests.
 		Cleanup: func(config interface{}) error {
 			cfg := config.(sftp.Config)
-			if !TestCleanupTempDirs {
+			if !rtest.TestCleanupTempDirs {
 				t.Logf("leaving test backend dir at %v", cfg.Path)
 			}
 
-			RemoveAll(t, cfg.Path)
+			rtest.RemoveAll(t, cfg.Path)
 			return nil
 		},
 	}
@@ -76,7 +75,7 @@ func newTestSuite(t testing.TB) *test.Suite {
 func TestBackendSFTP(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/sftp.TestBackendSFTP")
+			rtest.SkipDisallowed(t, "restic/backend/sftp.TestBackendSFTP")
 		}
 	}()
 
diff --git a/internal/backend/swift/swift_test.go b/internal/backend/swift/swift_test.go
index eea6302b2..ce8693c33 100644
--- a/internal/backend/swift/swift_test.go
+++ b/internal/backend/swift/swift_test.go
@@ -7,12 +7,11 @@ import (
 	"testing"
 	"time"
 
-	"github.com/restic/restic/internal/errors"
-	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
-
 	"github.com/restic/restic/internal/backend/swift"
 	"github.com/restic/restic/internal/backend/test"
+	"github.com/restic/restic/internal/errors"
+	"github.com/restic/restic/internal/restic"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func newSwiftTestSuite(t testing.TB) *test.Suite {
@@ -100,7 +99,7 @@ func newSwiftTestSuite(t testing.TB) *test.Suite {
 func TestBackendSwift(t *testing.T) {
 	defer func() {
 		if t.Skipped() {
-			SkipDisallowed(t, "restic/backend/swift.TestBackendSwift")
+			rtest.SkipDisallowed(t, "restic/backend/swift.TestBackendSwift")
 		}
 	}()
 
diff --git a/internal/backend/utils_test.go b/internal/backend/utils_test.go
index 09415f5e9..b281588fc 100644
--- a/internal/backend/utils_test.go
+++ b/internal/backend/utils_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/restic/restic/internal/backend"
 	"github.com/restic/restic/internal/backend/mem"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 const KiB = 1 << 10
@@ -19,14 +19,14 @@ func TestLoadAll(t *testing.T) {
 	b := mem.New()
 
 	for i := 0; i < 20; i++ {
-		data := Random(23+i, rand.Intn(MiB)+500*KiB)
+		data := rtest.Random(23+i, rand.Intn(MiB)+500*KiB)
 
 		id := restic.Hash(data)
 		err := b.Save(context.TODO(), restic.Handle{Name: id.String(), Type: restic.DataFile}, bytes.NewReader(data))
-		OK(t, err)
+		rtest.OK(t, err)
 
 		buf, err := backend.LoadAll(context.TODO(), b, restic.Handle{Type: restic.DataFile, Name: id.String()})
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(buf) != len(data) {
 			t.Errorf("length of returned buffer does not match, want %d, got %d", len(data), len(buf))
@@ -44,14 +44,14 @@ func TestLoadSmallBuffer(t *testing.T) {
 	b := mem.New()
 
 	for i := 0; i < 20; i++ {
-		data := Random(23+i, rand.Intn(MiB)+500*KiB)
+		data := rtest.Random(23+i, rand.Intn(MiB)+500*KiB)
 
 		id := restic.Hash(data)
 		err := b.Save(context.TODO(), restic.Handle{Name: id.String(), Type: restic.DataFile}, bytes.NewReader(data))
-		OK(t, err)
+		rtest.OK(t, err)
 
 		buf, err := backend.LoadAll(context.TODO(), b, restic.Handle{Type: restic.DataFile, Name: id.String()})
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(buf) != len(data) {
 			t.Errorf("length of returned buffer does not match, want %d, got %d", len(data), len(buf))
@@ -69,14 +69,14 @@ func TestLoadLargeBuffer(t *testing.T) {
 	b := mem.New()
 
 	for i := 0; i < 20; i++ {
-		data := Random(23+i, rand.Intn(MiB)+500*KiB)
+		data := rtest.Random(23+i, rand.Intn(MiB)+500*KiB)
 
 		id := restic.Hash(data)
 		err := b.Save(context.TODO(), restic.Handle{Name: id.String(), Type: restic.DataFile}, bytes.NewReader(data))
-		OK(t, err)
+		rtest.OK(t, err)
 
 		buf, err := backend.LoadAll(context.TODO(), b, restic.Handle{Type: restic.DataFile, Name: id.String()})
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(buf) != len(data) {
 			t.Errorf("length of returned buffer does not match, want %d, got %d", len(data), len(buf))
diff --git a/internal/crypto/crypto_test.go b/internal/crypto/crypto_test.go
index b9d3d4bca..f1a7b7994 100644
--- a/internal/crypto/crypto_test.go
+++ b/internal/crypto/crypto_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/restic/restic/internal/crypto"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 
 	"github.com/restic/chunker"
 )
@@ -23,24 +23,24 @@ func TestEncryptDecrypt(t *testing.T) {
 	}
 
 	for _, size := range tests {
-		data := Random(42, size)
+		data := rtest.Random(42, size)
 		buf := make([]byte, size+crypto.Extension)
 
 		ciphertext, err := k.Encrypt(buf, data)
-		OK(t, err)
-		Assert(t, len(ciphertext) == len(data)+crypto.Extension,
+		rtest.OK(t, err)
+		rtest.Assert(t, len(ciphertext) == len(data)+crypto.Extension,
 			"ciphertext length does not match: want %d, got %d",
 			len(data)+crypto.Extension, len(ciphertext))
 
 		plaintext := make([]byte, len(ciphertext))
 		n, err := k.Decrypt(plaintext, ciphertext)
-		OK(t, err)
+		rtest.OK(t, err)
 		plaintext = plaintext[:n]
-		Assert(t, len(plaintext) == len(data),
+		rtest.Assert(t, len(plaintext) == len(data),
 			"plaintext length does not match: want %d, got %d",
 			len(data), len(plaintext))
 
-		Equals(t, plaintext, data)
+		rtest.Equals(t, plaintext, data)
 	}
 }
 
@@ -50,21 +50,21 @@ func TestSmallBuffer(t *testing.T) {
 	size := 600
 	data := make([]byte, size)
 	_, err := io.ReadFull(rand.Reader, data)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	ciphertext := make([]byte, size/2)
 	ciphertext, err = k.Encrypt(ciphertext, data)
 	// this must extend the slice
-	Assert(t, cap(ciphertext) > size/2,
+	rtest.Assert(t, cap(ciphertext) > size/2,
 		"expected extended slice, but capacity is only %d bytes",
 		cap(ciphertext))
 
 	// check for the correct plaintext
 	plaintext := make([]byte, len(ciphertext))
 	n, err := k.Decrypt(plaintext, ciphertext)
-	OK(t, err)
+	rtest.OK(t, err)
 	plaintext = plaintext[:n]
-	Assert(t, bytes.Equal(plaintext, data),
+	rtest.Assert(t, bytes.Equal(plaintext, data),
 		"wrong plaintext returned")
 }
 
@@ -74,18 +74,18 @@ func TestSameBuffer(t *testing.T) {
 	size := 600
 	data := make([]byte, size)
 	_, err := io.ReadFull(rand.Reader, data)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	ciphertext := make([]byte, 0, size+crypto.Extension)
 
 	ciphertext, err = k.Encrypt(ciphertext, data)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	// use the same buffer for decryption
 	n, err := k.Decrypt(ciphertext, ciphertext)
-	OK(t, err)
+	rtest.OK(t, err)
 	ciphertext = ciphertext[:n]
-	Assert(t, bytes.Equal(ciphertext, data),
+	rtest.Assert(t, bytes.Equal(ciphertext, data),
 		"wrong plaintext returned")
 }
 
@@ -95,20 +95,20 @@ func TestCornerCases(t *testing.T) {
 	// nil plaintext should encrypt to the empty string
 	// nil ciphertext should allocate a new slice for the ciphertext
 	c, err := k.Encrypt(nil, nil)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	Assert(t, len(c) == crypto.Extension,
+	rtest.Assert(t, len(c) == crypto.Extension,
 		"wrong length returned for ciphertext, expected 0, got %d",
 		len(c))
 
 	// this should decrypt to nil
 	n, err := k.Decrypt(nil, c)
-	OK(t, err)
-	Equals(t, 0, n)
+	rtest.OK(t, err)
+	rtest.Equals(t, 0, n)
 
 	// test encryption for same slice, this should return an error
 	_, err = k.Encrypt(c, c)
-	Equals(t, crypto.ErrInvalidCiphertext, err)
+	rtest.Equals(t, crypto.ErrInvalidCiphertext, err)
 }
 
 func TestLargeEncrypt(t *testing.T) {
@@ -121,15 +121,15 @@ func TestLargeEncrypt(t *testing.T) {
 	for _, size := range []int{chunker.MaxSize, chunker.MaxSize + 1, chunker.MaxSize + 1<<20} {
 		data := make([]byte, size)
 		_, err := io.ReadFull(rand.Reader, data)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		ciphertext, err := k.Encrypt(make([]byte, size+crypto.Extension), data)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		plaintext, err := k.Decrypt([]byte{}, ciphertext)
-		OK(t, err)
+		rtest.OK(t, err)
 
-		Equals(t, plaintext, data)
+		rtest.Equals(t, plaintext, data)
 	}
 }
 
@@ -145,7 +145,7 @@ func BenchmarkEncrypt(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		_, err := k.Encrypt(buf, data)
-		OK(b, err)
+		rtest.OK(b, err)
 	}
 }
 
@@ -159,13 +159,13 @@ func BenchmarkDecrypt(b *testing.B) {
 	ciphertext := make([]byte, size+crypto.Extension)
 
 	ciphertext, err := k.Encrypt(ciphertext, data)
-	OK(b, err)
+	rtest.OK(b, err)
 
 	b.ResetTimer()
 	b.SetBytes(int64(size))
 
 	for i := 0; i < b.N; i++ {
 		_, err = k.Decrypt(plaintext, ciphertext)
-		OK(b, err)
+		rtest.OK(b, err)
 	}
 }
diff --git a/internal/fuse/file_test.go b/internal/fuse/file_test.go
index d8aae46de..121c218f5 100644
--- a/internal/fuse/file_test.go
+++ b/internal/fuse/file_test.go
@@ -17,7 +17,7 @@ import (
 	"bazil.org/fuse"
 	"bazil.org/fuse/fs"
 
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func testRead(t testing.TB, f *file, offset, length int, data []byte) {
@@ -31,7 +31,7 @@ func testRead(t testing.TB, f *file, offset, length int, data []byte) {
 	resp := &fuse.ReadResponse{
 		Data: data,
 	}
-	OK(t, f.Read(ctx, req, resp))
+	rtest.OK(t, f.Read(ctx, req, resp))
 }
 
 func firstSnapshotID(t testing.TB, repo restic.Repository) (first restic.ID) {
@@ -46,13 +46,13 @@ func firstSnapshotID(t testing.TB, repo restic.Repository) (first restic.ID) {
 func loadFirstSnapshot(t testing.TB, repo restic.Repository) *restic.Snapshot {
 	id := firstSnapshotID(t, repo)
 	sn, err := restic.LoadSnapshot(context.TODO(), repo, id)
-	OK(t, err)
+	rtest.OK(t, err)
 	return sn
 }
 
 func loadTree(t testing.TB, repo restic.Repository, id restic.ID) *restic.Tree {
 	tree, err := repo.LoadTree(context.TODO(), id)
-	OK(t, err)
+	rtest.OK(t, err)
 	return tree
 }
 
@@ -64,7 +64,7 @@ func TestFuseFile(t *testing.T) {
 	defer cancel()
 
 	timestamp, err := time.Parse(time.RFC3339, "2017-01-24T10:42:56+01:00")
-	OK(t, err)
+	rtest.OK(t, err)
 	restic.TestCreateSnapshot(t, repo, timestamp, 2, 0.1)
 
 	sn := loadFirstSnapshot(t, repo)
@@ -82,12 +82,12 @@ func TestFuseFile(t *testing.T) {
 	)
 	for _, id := range content {
 		size, err := repo.LookupBlobSize(id, restic.DataBlob)
-		OK(t, err)
+		rtest.OK(t, err)
 		filesize += uint64(size)
 
 		buf := restic.NewBlobBuffer(int(size))
 		n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if uint(n) != size {
 			t.Fatalf("not enough bytes read for id %v: want %v, got %v", id.Str(), size, n)
@@ -118,15 +118,15 @@ func TestFuseFile(t *testing.T) {
 
 	inode := fs.GenerateDynamicInode(1, "foo")
 	f, err := newFile(context.TODO(), root, inode, node)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	attr := fuse.Attr{}
-	OK(t, f.Attr(ctx, &attr))
+	rtest.OK(t, f.Attr(ctx, &attr))
 
-	Equals(t, inode, attr.Inode)
-	Equals(t, node.Mode, attr.Mode)
-	Equals(t, node.Size, attr.Size)
-	Equals(t, (node.Size/uint64(attr.BlockSize))+1, attr.Blocks)
+	rtest.Equals(t, inode, attr.Inode)
+	rtest.Equals(t, node.Mode, attr.Mode)
+	rtest.Equals(t, node.Size, attr.Size)
+	rtest.Equals(t, (node.Size/uint64(attr.BlockSize))+1, attr.Blocks)
 
 	for i := 0; i < 200; i++ {
 		offset := rand.Intn(int(filesize))
@@ -142,5 +142,5 @@ func TestFuseFile(t *testing.T) {
 		}
 	}
 
-	OK(t, f.Release(ctx, nil))
+	rtest.OK(t, f.Release(ctx, nil))
 }
diff --git a/internal/pack/pack_test.go b/internal/pack/pack_test.go
index fc1e7ae1a..a61b28a2b 100644
--- a/internal/pack/pack_test.go
+++ b/internal/pack/pack_test.go
@@ -14,7 +14,7 @@ import (
 	"github.com/restic/restic/internal/crypto"
 	"github.com/restic/restic/internal/pack"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 var testLens = []int{23, 31650, 25860, 10928, 13769, 19862, 5211, 127, 13690, 30231}
@@ -30,7 +30,7 @@ func newPack(t testing.TB, k *crypto.Key, lengths []int) ([]Buf, []byte, uint) {
 	for _, l := range lengths {
 		b := make([]byte, l)
 		_, err := io.ReadFull(rand.Reader, b)
-		OK(t, err)
+		rtest.OK(t, err)
 		h := sha256.Sum256(b)
 		bufs = append(bufs, Buf{data: b, id: h})
 	}
@@ -42,7 +42,7 @@ func newPack(t testing.TB, k *crypto.Key, lengths []int) ([]Buf, []byte, uint) {
 	}
 
 	_, err := p.Finalize()
-	OK(t, err)
+	rtest.OK(t, err)
 
 	packData := p.Writer().(*bytes.Buffer).Bytes()
 	return bufs, packData, p.Size()
@@ -60,27 +60,27 @@ func verifyBlobs(t testing.TB, bufs []Buf, k *crypto.Key, rd io.ReaderAt, packSi
 	written += restic.CiphertextLength(headerSize)
 
 	// check length
-	Equals(t, uint(written), packSize)
+	rtest.Equals(t, uint(written), packSize)
 
 	// read and parse it again
 	entries, err := pack.List(k, rd, int64(packSize))
-	OK(t, err)
-	Equals(t, len(entries), len(bufs))
+	rtest.OK(t, err)
+	rtest.Equals(t, len(entries), len(bufs))
 
 	var buf []byte
 	for i, b := range bufs {
 		e := entries[i]
-		Equals(t, b.id, e.ID)
+		rtest.Equals(t, b.id, e.ID)
 
 		if len(buf) < int(e.Length) {
 			buf = make([]byte, int(e.Length))
 		}
 		buf = buf[:int(e.Length)]
 		n, err := rd.ReadAt(buf, int64(e.Offset))
-		OK(t, err)
+		rtest.OK(t, err)
 		buf = buf[:n]
 
-		Assert(t, bytes.Equal(b.data, buf),
+		rtest.Assert(t, bytes.Equal(b.data, buf),
 			"data for blob %v doesn't match", i)
 	}
 }
@@ -90,7 +90,7 @@ func TestCreatePack(t *testing.T) {
 	k := crypto.NewRandomKey()
 
 	bufs, packData, packSize := newPack(t, k, testLens)
-	Equals(t, uint(len(packData)), packSize)
+	rtest.Equals(t, uint(len(packData)), packSize)
 	verifyBlobs(t, bufs, k, bytes.NewReader(packData), packSize)
 }
 
@@ -106,14 +106,14 @@ func TestBlobTypeJSON(t *testing.T) {
 	for _, test := range blobTypeJSON {
 		// test serialize
 		buf, err := json.Marshal(test.t)
-		OK(t, err)
-		Equals(t, test.res, string(buf))
+		rtest.OK(t, err)
+		rtest.Equals(t, test.res, string(buf))
 
 		// test unserialize
 		var v restic.BlobType
 		err = json.Unmarshal([]byte(test.res), &v)
-		OK(t, err)
-		Equals(t, test.t, v)
+		rtest.OK(t, err)
+		rtest.Equals(t, test.t, v)
 	}
 }
 
@@ -127,7 +127,7 @@ func TestUnpackReadSeeker(t *testing.T) {
 	id := restic.Hash(packData)
 
 	handle := restic.Handle{Type: restic.DataFile, Name: id.String()}
-	OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData)))
+	rtest.OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData)))
 	verifyBlobs(t, bufs, k, restic.ReaderAt(b, handle), packSize)
 }
 
@@ -140,6 +140,6 @@ func TestShortPack(t *testing.T) {
 	id := restic.Hash(packData)
 
 	handle := restic.Handle{Type: restic.DataFile, Name: id.String()}
-	OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData)))
+	rtest.OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData)))
 	verifyBlobs(t, bufs, k, restic.ReaderAt(b, handle), packSize)
 }
diff --git a/internal/pipe/pipe_test.go b/internal/pipe/pipe_test.go
index 377511b6c..1612987e7 100644
--- a/internal/pipe/pipe_test.go
+++ b/internal/pipe/pipe_test.go
@@ -12,7 +12,7 @@ import (
 
 	"github.com/restic/restic/internal/debug"
 	"github.com/restic/restic/internal/pipe"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 type stats struct {
@@ -27,7 +27,7 @@ func statPath(path string) (stats, error) {
 	var s stats
 
 	// count files and directories with filepath.Walk()
-	err := filepath.Walk(TestWalkerPath, func(p string, fi os.FileInfo, err error) error {
+	err := filepath.Walk(rtest.TestWalkerPath, func(p string, fi os.FileInfo, err error) error {
 		if fi == nil {
 			return err
 		}
@@ -47,20 +47,20 @@ func statPath(path string) (stats, error) {
 const maxWorkers = 100
 
 func TestPipelineWalkerWithSplit(t *testing.T) {
-	if TestWalkerPath == "" {
+	if rtest.TestWalkerPath == "" {
 		t.Skipf("walkerpath not set, skipping TestPipelineWalker")
 	}
 
 	var err error
-	if !filepath.IsAbs(TestWalkerPath) {
-		TestWalkerPath, err = filepath.Abs(TestWalkerPath)
-		OK(t, err)
+	if !filepath.IsAbs(rtest.TestWalkerPath) {
+		rtest.TestWalkerPath, err = filepath.Abs(rtest.TestWalkerPath)
+		rtest.OK(t, err)
 	}
 
-	before, err := statPath(TestWalkerPath)
-	OK(t, err)
+	before, err := statPath(rtest.TestWalkerPath)
+	rtest.OK(t, err)
 
-	t.Logf("walking path %s with %d dirs, %d files", TestWalkerPath,
+	t.Logf("walking path %s with %d dirs, %d files", rtest.TestWalkerPath,
 		before.dirs, before.files)
 
 	// account for top level dir
@@ -128,7 +128,7 @@ func TestPipelineWalkerWithSplit(t *testing.T) {
 	}()
 
 	resCh := make(chan pipe.Result, 1)
-	pipe.Walk(context.TODO(), []string{TestWalkerPath}, acceptAll, jobs, resCh)
+	pipe.Walk(context.TODO(), []string{rtest.TestWalkerPath}, acceptAll, jobs, resCh)
 
 	// wait for all workers to terminate
 	wg.Wait()
@@ -136,14 +136,14 @@ func TestPipelineWalkerWithSplit(t *testing.T) {
 	// wait for top-level blob
 	<-resCh
 
-	t.Logf("walked path %s with %d dirs, %d files", TestWalkerPath,
+	t.Logf("walked path %s with %d dirs, %d files", rtest.TestWalkerPath,
 		after.dirs, after.files)
 
-	Assert(t, before == after, "stats do not match, expected %v, got %v", before, after)
+	rtest.Assert(t, before == after, "stats do not match, expected %v, got %v", before, after)
 }
 
 func TestPipelineWalker(t *testing.T) {
-	if TestWalkerPath == "" {
+	if rtest.TestWalkerPath == "" {
 		t.Skipf("walkerpath not set, skipping TestPipelineWalker")
 	}
 
@@ -151,15 +151,15 @@ func TestPipelineWalker(t *testing.T) {
 	defer cancel()
 
 	var err error
-	if !filepath.IsAbs(TestWalkerPath) {
-		TestWalkerPath, err = filepath.Abs(TestWalkerPath)
-		OK(t, err)
+	if !filepath.IsAbs(rtest.TestWalkerPath) {
+		rtest.TestWalkerPath, err = filepath.Abs(rtest.TestWalkerPath)
+		rtest.OK(t, err)
 	}
 
-	before, err := statPath(TestWalkerPath)
-	OK(t, err)
+	before, err := statPath(rtest.TestWalkerPath)
+	rtest.OK(t, err)
 
-	t.Logf("walking path %s with %d dirs, %d files", TestWalkerPath,
+	t.Logf("walking path %s with %d dirs, %d files", rtest.TestWalkerPath,
 		before.dirs, before.files)
 
 	// account for top level dir
@@ -177,7 +177,7 @@ func TestPipelineWalker(t *testing.T) {
 					// channel is closed
 					return
 				}
-				Assert(t, job != nil, "job is nil")
+				rtest.Assert(t, job != nil, "job is nil")
 
 				switch j := job.(type) {
 				case pipe.Dir:
@@ -215,7 +215,7 @@ func TestPipelineWalker(t *testing.T) {
 	}
 
 	resCh := make(chan pipe.Result, 1)
-	pipe.Walk(ctx, []string{TestWalkerPath}, acceptAll, jobs, resCh)
+	pipe.Walk(ctx, []string{rtest.TestWalkerPath}, acceptAll, jobs, resCh)
 
 	// wait for all workers to terminate
 	wg.Wait()
@@ -223,10 +223,10 @@ func TestPipelineWalker(t *testing.T) {
 	// wait for top-level blob
 	<-resCh
 
-	t.Logf("walked path %s with %d dirs, %d files", TestWalkerPath,
+	t.Logf("walked path %s with %d dirs, %d files", rtest.TestWalkerPath,
 		after.dirs, after.files)
 
-	Assert(t, before == after, "stats do not match, expected %v, got %v", before, after)
+	rtest.Assert(t, before == after, "stats do not match, expected %v, got %v", before, after)
 }
 
 func createFile(filename, data string) error {
@@ -247,7 +247,7 @@ func createFile(filename, data string) error {
 
 func TestPipeWalkerError(t *testing.T) {
 	dir, err := ioutil.TempDir("", "restic-test-")
-	OK(t, err)
+	rtest.OK(t, err)
 
 	base := filepath.Base(dir)
 
@@ -264,13 +264,13 @@ func TestPipeWalkerError(t *testing.T) {
 		{[]string{}, false},
 	}
 
-	OK(t, os.Mkdir(filepath.Join(dir, "a"), 0755))
-	OK(t, os.Mkdir(filepath.Join(dir, "b"), 0755))
-	OK(t, os.Mkdir(filepath.Join(dir, "c"), 0755))
+	rtest.OK(t, os.Mkdir(filepath.Join(dir, "a"), 0755))
+	rtest.OK(t, os.Mkdir(filepath.Join(dir, "b"), 0755))
+	rtest.OK(t, os.Mkdir(filepath.Join(dir, "c"), 0755))
 
-	OK(t, createFile(filepath.Join(dir, "a", "file_a"), "file a"))
-	OK(t, createFile(filepath.Join(dir, "b", "file_b"), "file b"))
-	OK(t, createFile(filepath.Join(dir, "c", "file_c"), "file c"))
+	rtest.OK(t, createFile(filepath.Join(dir, "a", "file_a"), "file a"))
+	rtest.OK(t, createFile(filepath.Join(dir, "b", "file_b"), "file b"))
+	rtest.OK(t, createFile(filepath.Join(dir, "c", "file_c"), "file c"))
 
 	ranHook := false
 	testdir := filepath.Join(dir, "b")
@@ -286,7 +286,7 @@ func TestPipeWalkerError(t *testing.T) {
 		t.Logf("in hook, removing test file %v", testdir)
 		ranHook = true
 
-		OK(t, os.RemoveAll(testdir))
+		rtest.OK(t, os.RemoveAll(testdir))
 	})
 
 	ctx, cancel := context.WithCancel(context.TODO())
@@ -327,12 +327,12 @@ func TestPipeWalkerError(t *testing.T) {
 
 	cancel()
 
-	Assert(t, ranHook, "hook did not run")
-	OK(t, os.RemoveAll(dir))
+	rtest.Assert(t, ranHook, "hook did not run")
+	rtest.OK(t, os.RemoveAll(dir))
 }
 
 func BenchmarkPipelineWalker(b *testing.B) {
-	if TestWalkerPath == "" {
+	if rtest.TestWalkerPath == "" {
 		b.Skipf("walkerpath not set, skipping BenchPipelineWalker")
 	}
 
@@ -418,7 +418,7 @@ func BenchmarkPipelineWalker(b *testing.B) {
 		}()
 
 		resCh := make(chan pipe.Result, 1)
-		pipe.Walk(ctx, []string{TestWalkerPath}, acceptAll, jobs, resCh)
+		pipe.Walk(ctx, []string{rtest.TestWalkerPath}, acceptAll, jobs, resCh)
 
 		// wait for all workers to terminate
 		wg.Wait()
@@ -431,18 +431,18 @@ func BenchmarkPipelineWalker(b *testing.B) {
 }
 
 func TestPipelineWalkerMultiple(t *testing.T) {
-	if TestWalkerPath == "" {
+	if rtest.TestWalkerPath == "" {
 		t.Skipf("walkerpath not set, skipping TestPipelineWalker")
 	}
 
 	ctx, cancel := context.WithCancel(context.TODO())
 	defer cancel()
 
-	paths, err := filepath.Glob(filepath.Join(TestWalkerPath, "*"))
-	OK(t, err)
+	paths, err := filepath.Glob(filepath.Join(rtest.TestWalkerPath, "*"))
+	rtest.OK(t, err)
 
-	before, err := statPath(TestWalkerPath)
-	OK(t, err)
+	before, err := statPath(rtest.TestWalkerPath)
+	rtest.OK(t, err)
 
 	t.Logf("walking paths %v with %d dirs, %d files", paths,
 		before.dirs, before.files)
@@ -459,7 +459,7 @@ func TestPipelineWalkerMultiple(t *testing.T) {
 					// channel is closed
 					return
 				}
-				Assert(t, job != nil, "job is nil")
+				rtest.Assert(t, job != nil, "job is nil")
 
 				switch j := job.(type) {
 				case pipe.Dir:
@@ -507,7 +507,7 @@ func TestPipelineWalkerMultiple(t *testing.T) {
 
 	t.Logf("walked %d paths with %d dirs, %d files", len(paths), after.dirs, after.files)
 
-	Assert(t, before == after, "stats do not match, expected %v, got %v", before, after)
+	rtest.Assert(t, before == after, "stats do not match, expected %v, got %v", before, after)
 }
 
 func dirsInPath(path string) int {
@@ -530,7 +530,7 @@ func TestPipeWalkerRoot(t *testing.T) {
 	}
 
 	cwd, err := os.Getwd()
-	OK(t, err)
+	rtest.OK(t, err)
 
 	testPaths := []string{
 		string(filepath.Separator),
@@ -546,11 +546,11 @@ func TestPipeWalkerRoot(t *testing.T) {
 func testPipeWalkerRootWithPath(path string, t *testing.T) {
 	pattern := filepath.Join(path, "*")
 	rootPaths, err := filepath.Glob(pattern)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	for i, p := range rootPaths {
 		rootPaths[i], err = filepath.Rel(path, p)
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 
 	t.Logf("paths in %v (pattern %q) expanded to %v items", path, pattern, len(rootPaths))
@@ -571,7 +571,7 @@ func testPipeWalkerRootWithPath(path string, t *testing.T) {
 
 	filter := func(p string, fi os.FileInfo) bool {
 		p, err := filepath.Rel(path, p)
-		OK(t, err)
+		rtest.OK(t, err)
 		return dirsInPath(p) <= 1
 	}
 
diff --git a/internal/repository/index_test.go b/internal/repository/index_test.go
index 4cd315c66..f0ca4e19b 100644
--- a/internal/repository/index_test.go
+++ b/internal/repository/index_test.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestIndexSerialize(t *testing.T) {
@@ -52,43 +52,43 @@ func TestIndexSerialize(t *testing.T) {
 
 	wr := bytes.NewBuffer(nil)
 	err := idx.Encode(wr)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	idx2, err := repository.DecodeIndex(wr.Bytes())
-	OK(t, err)
-	Assert(t, idx2 != nil,
+	rtest.OK(t, err)
+	rtest.Assert(t, idx2 != nil,
 		"nil returned for decoded index")
 
 	wr2 := bytes.NewBuffer(nil)
 	err = idx2.Encode(wr2)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	for _, testBlob := range tests {
 		list, err := idx.Lookup(testBlob.id, testBlob.tpe)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(list) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list), list)
 		}
 		result := list[0]
 
-		Equals(t, testBlob.pack, result.PackID)
-		Equals(t, testBlob.tpe, result.Type)
-		Equals(t, testBlob.offset, result.Offset)
-		Equals(t, testBlob.length, result.Length)
+		rtest.Equals(t, testBlob.pack, result.PackID)
+		rtest.Equals(t, testBlob.tpe, result.Type)
+		rtest.Equals(t, testBlob.offset, result.Offset)
+		rtest.Equals(t, testBlob.length, result.Length)
 
 		list2, err := idx2.Lookup(testBlob.id, testBlob.tpe)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(list2) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list2), list2)
 		}
 		result2 := list2[0]
 
-		Equals(t, testBlob.pack, result2.PackID)
-		Equals(t, testBlob.tpe, result2.Type)
-		Equals(t, testBlob.offset, result2.Offset)
-		Equals(t, testBlob.length, result2.Length)
+		rtest.Equals(t, testBlob.pack, result2.PackID)
+		rtest.Equals(t, testBlob.tpe, result2.Type)
+		rtest.Equals(t, testBlob.offset, result2.Offset)
+		rtest.Equals(t, testBlob.length, result2.Length)
 	}
 
 	// add more blobs to idx
@@ -125,28 +125,28 @@ func TestIndexSerialize(t *testing.T) {
 	// serialize idx, unserialize to idx3
 	wr3 := bytes.NewBuffer(nil)
 	err = idx.Finalize(wr3)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	Assert(t, idx.Final(),
+	rtest.Assert(t, idx.Final(),
 		"index not final after encoding")
 
 	id := restic.NewRandomID()
-	OK(t, idx.SetID(id))
+	rtest.OK(t, idx.SetID(id))
 	id2, err := idx.ID()
-	Assert(t, id2.Equal(id),
+	rtest.Assert(t, id2.Equal(id),
 		"wrong ID returned: want %v, got %v", id, id2)
 
 	idx3, err := repository.DecodeIndex(wr3.Bytes())
-	OK(t, err)
-	Assert(t, idx3 != nil,
+	rtest.OK(t, err)
+	rtest.Assert(t, idx3 != nil,
 		"nil returned for decoded index")
-	Assert(t, idx3.Final(),
+	rtest.Assert(t, idx3.Final(),
 		"decoded index is not final")
 
 	// all new blobs must be in the index
 	for _, testBlob := range newtests {
 		list, err := idx3.Lookup(testBlob.id, testBlob.tpe)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(list) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list), list)
@@ -154,10 +154,10 @@ func TestIndexSerialize(t *testing.T) {
 
 		blob := list[0]
 
-		Equals(t, testBlob.pack, blob.PackID)
-		Equals(t, testBlob.tpe, blob.Type)
-		Equals(t, testBlob.offset, blob.Offset)
-		Equals(t, testBlob.length, blob.Length)
+		rtest.Equals(t, testBlob.pack, blob.PackID)
+		rtest.Equals(t, testBlob.tpe, blob.Type)
+		rtest.Equals(t, testBlob.offset, blob.Offset)
+		rtest.Equals(t, testBlob.length, blob.Length)
 	}
 }
 
@@ -190,7 +190,7 @@ func TestIndexSize(t *testing.T) {
 	wr := bytes.NewBuffer(nil)
 
 	err := idx.Encode(wr)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	t.Logf("Index file size for %d blobs in %d packs is %d", blobs*packs, packs, wr.Len())
 }
@@ -289,11 +289,11 @@ func TestIndexUnserialize(t *testing.T) {
 	oldIdx := restic.IDs{restic.TestParseID("ed54ae36197f4745ebc4b54d10e0f623eaaaedd03013eb7ae90df881b7781452")}
 
 	idx, err := repository.DecodeIndex(docExample)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	for _, test := range exampleTests {
 		list, err := idx.Lookup(test.id, test.tpe)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(list) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", test.id.Str(), len(list), list)
@@ -302,13 +302,13 @@ func TestIndexUnserialize(t *testing.T) {
 
 		t.Logf("looking for blob %v/%v, got %v", test.tpe, test.id.Str(), blob)
 
-		Equals(t, test.packID, blob.PackID)
-		Equals(t, test.tpe, blob.Type)
-		Equals(t, test.offset, blob.Offset)
-		Equals(t, test.length, blob.Length)
+		rtest.Equals(t, test.packID, blob.PackID)
+		rtest.Equals(t, test.tpe, blob.Type)
+		rtest.Equals(t, test.offset, blob.Offset)
+		rtest.Equals(t, test.length, blob.Length)
 	}
 
-	Equals(t, oldIdx, idx.Supersedes())
+	rtest.Equals(t, oldIdx, idx.Supersedes())
 
 	blobs := idx.ListPack(exampleLookupTest.packID)
 	if len(blobs) != len(exampleLookupTest.blobs) {
@@ -331,30 +331,30 @@ func BenchmarkDecodeIndex(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		_, err := repository.DecodeIndex(docExample)
-		OK(b, err)
+		rtest.OK(b, err)
 	}
 }
 
 func TestIndexUnserializeOld(t *testing.T) {
 	idx, err := repository.DecodeOldIndex(docOldExample)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	for _, test := range exampleTests {
 		list, err := idx.Lookup(test.id, test.tpe)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if len(list) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", test.id.Str(), len(list), list)
 		}
 		blob := list[0]
 
-		Equals(t, test.packID, blob.PackID)
-		Equals(t, test.tpe, blob.Type)
-		Equals(t, test.offset, blob.Offset)
-		Equals(t, test.length, blob.Length)
+		rtest.Equals(t, test.packID, blob.PackID)
+		rtest.Equals(t, test.tpe, blob.Type)
+		rtest.Equals(t, test.offset, blob.Offset)
+		rtest.Equals(t, test.length, blob.Length)
 	}
 
-	Equals(t, 0, len(idx.Supersedes()))
+	rtest.Equals(t, 0, len(idx.Supersedes()))
 }
 
 func TestIndexPacks(t *testing.T) {
@@ -377,5 +377,5 @@ func TestIndexPacks(t *testing.T) {
 	}
 
 	idxPacks := idx.Packs()
-	Assert(t, packs.Equals(idxPacks), "packs in index do not match packs added to index")
+	rtest.Assert(t, packs.Equals(idxPacks), "packs in index do not match packs added to index")
 }
diff --git a/internal/repository/parallel_test.go b/internal/repository/parallel_test.go
index a7ebdb5e0..9fa3687bb 100644
--- a/internal/repository/parallel_test.go
+++ b/internal/repository/parallel_test.go
@@ -10,7 +10,7 @@ import (
 	"github.com/restic/restic/internal/restic"
 
 	"github.com/restic/restic/internal/repository"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 type testIDs []string
@@ -102,7 +102,7 @@ func TestFilesInParallel(t *testing.T) {
 
 	for n := uint(1); n < 5; n++ {
 		err := repository.FilesInParallel(context.TODO(), lister, restic.DataFile, n*100, f)
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 }
 
@@ -122,6 +122,6 @@ func TestFilesInParallelWithError(t *testing.T) {
 
 	for n := uint(1); n < 5; n++ {
 		err := repository.FilesInParallel(context.TODO(), lister, restic.DataFile, n*100, f)
-		Equals(t, errTest, err)
+		rtest.Equals(t, errTest, err)
 	}
 }
diff --git a/internal/repository/repository_test.go b/internal/repository/repository_test.go
index 7211058b0..d3b9dec93 100644
--- a/internal/repository/repository_test.go
+++ b/internal/repository/repository_test.go
@@ -13,7 +13,7 @@ import (
 	"github.com/restic/restic/internal/archiver"
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 var testSizes = []int{5, 23, 2<<18 + 23, 1 << 20}
@@ -27,30 +27,30 @@ func TestSave(t *testing.T) {
 	for _, size := range testSizes {
 		data := make([]byte, size)
 		_, err := io.ReadFull(rnd, data)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		id := restic.Hash(data)
 
 		// save
 		sid, err := repo.SaveBlob(context.TODO(), restic.DataBlob, data, restic.ID{})
-		OK(t, err)
+		rtest.OK(t, err)
 
-		Equals(t, id, sid)
+		rtest.Equals(t, id, sid)
 
-		OK(t, repo.Flush())
-		// OK(t, repo.SaveIndex())
+		rtest.OK(t, repo.Flush())
+		// rtest.OK(t, repo.SaveIndex())
 
 		// read back
 		buf := restic.NewBlobBuffer(size)
 		n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf)
-		OK(t, err)
-		Equals(t, len(buf), n)
+		rtest.OK(t, err)
+		rtest.Equals(t, len(buf), n)
 
-		Assert(t, len(buf) == len(data),
+		rtest.Assert(t, len(buf) == len(data),
 			"number of bytes read back does not match: expected %d, got %d",
 			len(data), len(buf))
 
-		Assert(t, bytes.Equal(buf, data),
+		rtest.Assert(t, bytes.Equal(buf, data),
 			"data does not match: expected %02x, got %02x",
 			data, buf)
 	}
@@ -63,28 +63,28 @@ func TestSaveFrom(t *testing.T) {
 	for _, size := range testSizes {
 		data := make([]byte, size)
 		_, err := io.ReadFull(rnd, data)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		id := restic.Hash(data)
 
 		// save
 		id2, err := repo.SaveBlob(context.TODO(), restic.DataBlob, data, id)
-		OK(t, err)
-		Equals(t, id, id2)
+		rtest.OK(t, err)
+		rtest.Equals(t, id, id2)
 
-		OK(t, repo.Flush())
+		rtest.OK(t, repo.Flush())
 
 		// read back
 		buf := restic.NewBlobBuffer(size)
 		n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf)
-		OK(t, err)
-		Equals(t, len(buf), n)
+		rtest.OK(t, err)
+		rtest.Equals(t, len(buf), n)
 
-		Assert(t, len(buf) == len(data),
+		rtest.Assert(t, len(buf) == len(data),
 			"number of bytes read back does not match: expected %d, got %d",
 			len(data), len(buf))
 
-		Assert(t, bytes.Equal(buf, data),
+		rtest.Assert(t, bytes.Equal(buf, data),
 			"data does not match: expected %02x, got %02x",
 			data, buf)
 	}
@@ -98,7 +98,7 @@ func BenchmarkSaveAndEncrypt(t *testing.B) {
 
 	data := make([]byte, size)
 	_, err := io.ReadFull(rnd, data)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	id := restic.ID(sha256.Sum256(data))
 
@@ -108,7 +108,7 @@ func BenchmarkSaveAndEncrypt(t *testing.B) {
 	for i := 0; i < t.N; i++ {
 		// save
 		_, err = repo.SaveBlob(context.TODO(), restic.DataBlob, data, id)
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 }
 
@@ -116,35 +116,35 @@ func TestLoadTree(t *testing.T) {
 	repo, cleanup := repository.TestRepository(t)
 	defer cleanup()
 
-	if BenchArchiveDirectory == "" {
+	if rtest.BenchArchiveDirectory == "" {
 		t.Skip("benchdir not set, skipping")
 	}
 
 	// archive a few files
-	sn := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil)
-	OK(t, repo.Flush())
+	sn := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil)
+	rtest.OK(t, repo.Flush())
 
 	_, err := repo.LoadTree(context.TODO(), *sn.Tree)
-	OK(t, err)
+	rtest.OK(t, err)
 }
 
 func BenchmarkLoadTree(t *testing.B) {
 	repo, cleanup := repository.TestRepository(t)
 	defer cleanup()
 
-	if BenchArchiveDirectory == "" {
+	if rtest.BenchArchiveDirectory == "" {
 		t.Skip("benchdir not set, skipping")
 	}
 
 	// archive a few files
-	sn := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil)
-	OK(t, repo.Flush())
+	sn := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil)
+	rtest.OK(t, repo.Flush())
 
 	t.ResetTimer()
 
 	for i := 0; i < t.N; i++ {
 		_, err := repo.LoadTree(context.TODO(), *sn.Tree)
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 }
 
@@ -155,11 +155,11 @@ func TestLoadBlob(t *testing.T) {
 	length := 1000000
 	buf := restic.NewBlobBuffer(length)
 	_, err := io.ReadFull(rnd, buf)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	id, err := repo.SaveBlob(context.TODO(), restic.DataBlob, buf, restic.ID{})
-	OK(t, err)
-	OK(t, repo.Flush())
+	rtest.OK(t, err)
+	rtest.OK(t, repo.Flush())
 
 	// first, test with buffers that are too small
 	for _, testlength := range []int{length - 20, length, restic.CiphertextLength(length) - 1} {
@@ -200,18 +200,18 @@ func BenchmarkLoadBlob(b *testing.B) {
 	length := 1000000
 	buf := restic.NewBlobBuffer(length)
 	_, err := io.ReadFull(rnd, buf)
-	OK(b, err)
+	rtest.OK(b, err)
 
 	id, err := repo.SaveBlob(context.TODO(), restic.DataBlob, buf, restic.ID{})
-	OK(b, err)
-	OK(b, repo.Flush())
+	rtest.OK(b, err)
+	rtest.OK(b, repo.Flush())
 
 	b.ResetTimer()
 	b.SetBytes(int64(length))
 
 	for i := 0; i < b.N; i++ {
 		n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf)
-		OK(b, err)
+		rtest.OK(b, err)
 		if n != length {
 			b.Errorf("wanted %d bytes, got %d", length, n)
 		}
@@ -230,20 +230,20 @@ func BenchmarkLoadAndDecrypt(b *testing.B) {
 	length := 1000000
 	buf := restic.NewBlobBuffer(length)
 	_, err := io.ReadFull(rnd, buf)
-	OK(b, err)
+	rtest.OK(b, err)
 
 	dataID := restic.Hash(buf)
 
 	storageID, err := repo.SaveUnpacked(context.TODO(), restic.DataFile, buf)
-	OK(b, err)
-	// OK(b, repo.Flush())
+	rtest.OK(b, err)
+	// rtest.OK(b, repo.Flush())
 
 	b.ResetTimer()
 	b.SetBytes(int64(length))
 
 	for i := 0; i < b.N; i++ {
 		data, err := repo.LoadAndDecrypt(context.TODO(), restic.DataFile, storageID)
-		OK(b, err)
+		rtest.OK(b, err)
 		if len(data) != length {
 			b.Errorf("wanted %d bytes, got %d", length, len(data))
 		}
@@ -259,7 +259,7 @@ func TestLoadJSONUnpacked(t *testing.T) {
 	repo, cleanup := repository.TestRepository(t)
 	defer cleanup()
 
-	if BenchArchiveDirectory == "" {
+	if rtest.BenchArchiveDirectory == "" {
 		t.Skip("benchdir not set, skipping")
 	}
 
@@ -269,26 +269,26 @@ func TestLoadJSONUnpacked(t *testing.T) {
 	sn.Username = "test!"
 
 	id, err := repo.SaveJSONUnpacked(context.TODO(), restic.SnapshotFile, &sn)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	var sn2 restic.Snapshot
 
 	// restore
 	err = repo.LoadJSONUnpacked(context.TODO(), restic.SnapshotFile, id, &sn2)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	Equals(t, sn.Hostname, sn2.Hostname)
-	Equals(t, sn.Username, sn2.Username)
+	rtest.Equals(t, sn.Hostname, sn2.Hostname)
+	rtest.Equals(t, sn.Username, sn2.Username)
 }
 
 var repoFixture = filepath.Join("testdata", "test-repo.tar.gz")
 
 func TestRepositoryLoadIndex(t *testing.T) {
-	repodir, cleanup := Env(t, repoFixture)
+	repodir, cleanup := rtest.Env(t, repoFixture)
 	defer cleanup()
 
 	repo := repository.TestOpenLocal(t, repodir)
-	OK(t, repo.LoadIndex(context.TODO()))
+	rtest.OK(t, repo.LoadIndex(context.TODO()))
 }
 
 func BenchmarkLoadIndex(b *testing.B) {
@@ -312,18 +312,18 @@ func BenchmarkLoadIndex(b *testing.B) {
 	}
 
 	id, err := repository.SaveIndex(context.TODO(), repo, idx)
-	OK(b, err)
+	rtest.OK(b, err)
 
 	b.Logf("index saved as %v (%v entries)", id.Str(), idx.Count(restic.DataBlob))
 	fi, err := repo.Backend().Stat(context.TODO(), restic.Handle{Type: restic.IndexFile, Name: id.String()})
-	OK(b, err)
+	rtest.OK(b, err)
 	b.Logf("filesize is %v", fi.Size)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
 		_, err := repository.LoadIndex(context.TODO(), repo, id)
-		OK(b, err)
+		rtest.OK(b, err)
 	}
 }
 
@@ -334,10 +334,10 @@ func saveRandomDataBlobs(t testing.TB, repo restic.Repository, num int, sizeMax
 
 		buf := make([]byte, size)
 		_, err := io.ReadFull(rnd, buf)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		_, err = repo.SaveBlob(context.TODO(), restic.DataBlob, buf, restic.ID{})
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 }
 
@@ -352,26 +352,26 @@ func TestRepositoryIncrementalIndex(t *testing.T) {
 		// add 3 packs, write intermediate index
 		for i := 0; i < 3; i++ {
 			saveRandomDataBlobs(t, repo, 5, 1<<15)
-			OK(t, repo.Flush())
+			rtest.OK(t, repo.Flush())
 		}
 
-		OK(t, repo.SaveFullIndex(context.TODO()))
+		rtest.OK(t, repo.SaveFullIndex(context.TODO()))
 	}
 
 	// add another 5 packs
 	for i := 0; i < 5; i++ {
 		saveRandomDataBlobs(t, repo, 5, 1<<15)
-		OK(t, repo.Flush())
+		rtest.OK(t, repo.Flush())
 	}
 
 	// save final index
-	OK(t, repo.SaveIndex(context.TODO()))
+	rtest.OK(t, repo.SaveIndex(context.TODO()))
 
 	packEntries := make(map[restic.ID]map[restic.ID]struct{})
 
 	for id := range repo.List(context.TODO(), restic.IndexFile) {
 		idx, err := repository.LoadIndex(context.TODO(), repo, id)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		for pb := range idx.Each(context.TODO()) {
 			if _, ok := packEntries[pb.PackID]; !ok {
diff --git a/internal/restic/config_test.go b/internal/restic/config_test.go
index db06b23f5..dd3ddcc74 100644
--- a/internal/restic/config_test.go
+++ b/internal/restic/config_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 type saver func(restic.FileType, interface{}) (restic.ID, error)
@@ -23,7 +23,7 @@ func (l loader) LoadJSONUnpacked(ctx context.Context, t restic.FileType, id rest
 func TestConfig(t *testing.T) {
 	resultConfig := restic.Config{}
 	save := func(tpe restic.FileType, arg interface{}) (restic.ID, error) {
-		Assert(t, tpe == restic.ConfigFile,
+		rtest.Assert(t, tpe == restic.ConfigFile,
 			"wrong backend type: got %v, wanted %v",
 			tpe, restic.ConfigFile)
 
@@ -33,12 +33,12 @@ func TestConfig(t *testing.T) {
 	}
 
 	cfg1, err := restic.CreateConfig()
-	OK(t, err)
+	rtest.OK(t, err)
 
 	_, err = saver(save).SaveJSONUnpacked(restic.ConfigFile, cfg1)
 
 	load := func(ctx context.Context, tpe restic.FileType, id restic.ID, arg interface{}) error {
-		Assert(t, tpe == restic.ConfigFile,
+		rtest.Assert(t, tpe == restic.ConfigFile,
 			"wrong backend type: got %v, wanted %v",
 			tpe, restic.ConfigFile)
 
@@ -48,8 +48,8 @@ func TestConfig(t *testing.T) {
 	}
 
 	cfg2, err := restic.LoadConfig(context.TODO(), loader(load))
-	OK(t, err)
+	rtest.OK(t, err)
 
-	Assert(t, cfg1 == cfg2,
+	rtest.Assert(t, cfg1 == cfg2,
 		"configs aren't equal: %v != %v", cfg1, cfg2)
 }
diff --git a/internal/restic/hardlinks_index_test.go b/internal/restic/hardlinks_index_test.go
index a30456cf0..7e4bcd51a 100644
--- a/internal/restic/hardlinks_index_test.go
+++ b/internal/restic/hardlinks_index_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 // TestHardLinks contains various tests for HardlinkIndex.
@@ -17,19 +17,19 @@ func TestHardLinks(t *testing.T) {
 
 	var sresult string
 	sresult = idx.GetFilename(1, 2)
-	Equals(t, sresult, "inode1-file1-on-device2")
+	rtest.Equals(t, sresult, "inode1-file1-on-device2")
 
 	sresult = idx.GetFilename(2, 3)
-	Equals(t, sresult, "inode2-file2-on-device3")
+	rtest.Equals(t, sresult, "inode2-file2-on-device3")
 
 	var bresult bool
 	bresult = idx.Has(1, 2)
-	Equals(t, bresult, true)
+	rtest.Equals(t, bresult, true)
 
 	bresult = idx.Has(1, 3)
-	Equals(t, bresult, false)
+	rtest.Equals(t, bresult, false)
 
 	idx.Remove(1, 2)
 	bresult = idx.Has(1, 2)
-	Equals(t, bresult, false)
+	rtest.Equals(t, bresult, false)
 }
diff --git a/internal/restic/lock_test.go b/internal/restic/lock_test.go
index b0b03abce..a3b4936c9 100644
--- a/internal/restic/lock_test.go
+++ b/internal/restic/lock_test.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestLock(t *testing.T) {
@@ -16,9 +16,9 @@ func TestLock(t *testing.T) {
 	defer cleanup()
 
 	lock, err := restic.NewLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	OK(t, lock.Unlock())
+	rtest.OK(t, lock.Unlock())
 }
 
 func TestDoubleUnlock(t *testing.T) {
@@ -26,12 +26,12 @@ func TestDoubleUnlock(t *testing.T) {
 	defer cleanup()
 
 	lock, err := restic.NewLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	OK(t, lock.Unlock())
+	rtest.OK(t, lock.Unlock())
 
 	err = lock.Unlock()
-	Assert(t, err != nil,
+	rtest.Assert(t, err != nil,
 		"double unlock didn't return an error, got %v", err)
 }
 
@@ -40,13 +40,13 @@ func TestMultipleLock(t *testing.T) {
 	defer cleanup()
 
 	lock1, err := restic.NewLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	lock2, err := restic.NewLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	OK(t, lock1.Unlock())
-	OK(t, lock2.Unlock())
+	rtest.OK(t, lock1.Unlock())
+	rtest.OK(t, lock2.Unlock())
 }
 
 func TestLockExclusive(t *testing.T) {
@@ -54,8 +54,8 @@ func TestLockExclusive(t *testing.T) {
 	defer cleanup()
 
 	elock, err := restic.NewExclusiveLock(context.TODO(), repo)
-	OK(t, err)
-	OK(t, elock.Unlock())
+	rtest.OK(t, err)
+	rtest.OK(t, elock.Unlock())
 }
 
 func TestLockOnExclusiveLockedRepo(t *testing.T) {
@@ -63,16 +63,16 @@ func TestLockOnExclusiveLockedRepo(t *testing.T) {
 	defer cleanup()
 
 	elock, err := restic.NewExclusiveLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	lock, err := restic.NewLock(context.TODO(), repo)
-	Assert(t, err != nil,
+	rtest.Assert(t, err != nil,
 		"create normal lock with exclusively locked repo didn't return an error")
-	Assert(t, restic.IsAlreadyLocked(err),
+	rtest.Assert(t, restic.IsAlreadyLocked(err),
 		"create normal lock with exclusively locked repo didn't return the correct error")
 
-	OK(t, lock.Unlock())
-	OK(t, elock.Unlock())
+	rtest.OK(t, lock.Unlock())
+	rtest.OK(t, elock.Unlock())
 }
 
 func TestExclusiveLockOnLockedRepo(t *testing.T) {
@@ -80,16 +80,16 @@ func TestExclusiveLockOnLockedRepo(t *testing.T) {
 	defer cleanup()
 
 	elock, err := restic.NewLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	lock, err := restic.NewExclusiveLock(context.TODO(), repo)
-	Assert(t, err != nil,
+	rtest.Assert(t, err != nil,
 		"create normal lock with exclusively locked repo didn't return an error")
-	Assert(t, restic.IsAlreadyLocked(err),
+	rtest.Assert(t, restic.IsAlreadyLocked(err),
 		"create normal lock with exclusively locked repo didn't return the correct error")
 
-	OK(t, lock.Unlock())
-	OK(t, elock.Unlock())
+	rtest.OK(t, lock.Unlock())
+	rtest.OK(t, elock.Unlock())
 }
 
 func createFakeLock(repo restic.Repository, t time.Time, pid int) (restic.ID, error) {
@@ -141,7 +141,7 @@ var staleLockTests = []struct {
 
 func TestLockStale(t *testing.T) {
 	hostname, err := os.Hostname()
-	OK(t, err)
+	rtest.OK(t, err)
 
 	otherHostname := "other-" + hostname
 
@@ -152,12 +152,12 @@ func TestLockStale(t *testing.T) {
 			Hostname: hostname,
 		}
 
-		Assert(t, lock.Stale() == test.stale,
+		rtest.Assert(t, lock.Stale() == test.stale,
 			"TestStaleLock: test %d failed: expected stale: %v, got %v",
 			i, test.stale, !test.stale)
 
 		lock.Hostname = otherHostname
-		Assert(t, lock.Stale() == test.staleOnOtherHost,
+		rtest.Assert(t, lock.Stale() == test.staleOnOtherHost,
 			"TestStaleLock: test %d failed: expected staleOnOtherHost: %v, got %v",
 			i, test.staleOnOtherHost, !test.staleOnOtherHost)
 	}
@@ -166,7 +166,7 @@ func TestLockStale(t *testing.T) {
 func lockExists(repo restic.Repository, t testing.TB, id restic.ID) bool {
 	h := restic.Handle{Type: restic.LockFile, Name: id.String()}
 	exists, err := repo.Backend().Test(context.TODO(), h)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	return exists
 }
@@ -176,24 +176,24 @@ func TestLockWithStaleLock(t *testing.T) {
 	defer cleanup()
 
 	id1, err := createFakeLock(repo, time.Now().Add(-time.Hour), os.Getpid())
-	OK(t, err)
+	rtest.OK(t, err)
 
 	id2, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid())
-	OK(t, err)
+	rtest.OK(t, err)
 
 	id3, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid()+500000)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	OK(t, restic.RemoveStaleLocks(context.TODO(), repo))
+	rtest.OK(t, restic.RemoveStaleLocks(context.TODO(), repo))
 
-	Assert(t, lockExists(repo, t, id1) == false,
+	rtest.Assert(t, lockExists(repo, t, id1) == false,
 		"stale lock still exists after RemoveStaleLocks was called")
-	Assert(t, lockExists(repo, t, id2) == true,
+	rtest.Assert(t, lockExists(repo, t, id2) == true,
 		"non-stale lock was removed by RemoveStaleLocks")
-	Assert(t, lockExists(repo, t, id3) == false,
+	rtest.Assert(t, lockExists(repo, t, id3) == false,
 		"stale lock still exists after RemoveStaleLocks was called")
 
-	OK(t, removeLock(repo, id2))
+	rtest.OK(t, removeLock(repo, id2))
 }
 
 func TestRemoveAllLocks(t *testing.T) {
@@ -201,21 +201,21 @@ func TestRemoveAllLocks(t *testing.T) {
 	defer cleanup()
 
 	id1, err := createFakeLock(repo, time.Now().Add(-time.Hour), os.Getpid())
-	OK(t, err)
+	rtest.OK(t, err)
 
 	id2, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid())
-	OK(t, err)
+	rtest.OK(t, err)
 
 	id3, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid()+500000)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	OK(t, restic.RemoveAllLocks(context.TODO(), repo))
+	rtest.OK(t, restic.RemoveAllLocks(context.TODO(), repo))
 
-	Assert(t, lockExists(repo, t, id1) == false,
+	rtest.Assert(t, lockExists(repo, t, id1) == false,
 		"lock still exists after RemoveAllLocks was called")
-	Assert(t, lockExists(repo, t, id2) == false,
+	rtest.Assert(t, lockExists(repo, t, id2) == false,
 		"lock still exists after RemoveAllLocks was called")
-	Assert(t, lockExists(repo, t, id3) == false,
+	rtest.Assert(t, lockExists(repo, t, id3) == false,
 		"lock still exists after RemoveAllLocks was called")
 }
 
@@ -224,7 +224,7 @@ func TestLockRefresh(t *testing.T) {
 	defer cleanup()
 
 	lock, err := restic.NewLock(context.TODO(), repo)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	var lockID *restic.ID
 	for id := range repo.List(context.TODO(), restic.LockFile) {
@@ -234,7 +234,7 @@ func TestLockRefresh(t *testing.T) {
 		lockID = &id
 	}
 
-	OK(t, lock.Refresh(context.TODO()))
+	rtest.OK(t, lock.Refresh(context.TODO()))
 
 	var lockID2 *restic.ID
 	for id := range repo.List(context.TODO(), restic.LockFile) {
@@ -244,7 +244,7 @@ func TestLockRefresh(t *testing.T) {
 		lockID2 = &id
 	}
 
-	Assert(t, !lockID.Equal(*lockID2),
+	rtest.Assert(t, !lockID.Equal(*lockID2),
 		"expected a new ID after lock refresh, got the same")
-	OK(t, lock.Unlock())
+	rtest.OK(t, lock.Unlock())
 }
diff --git a/internal/restic/node_test.go b/internal/restic/node_test.go
index 47a9abdb2..6b0a19cd5 100644
--- a/internal/restic/node_test.go
+++ b/internal/restic/node_test.go
@@ -10,7 +10,7 @@ import (
 	"time"
 
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func BenchmarkNodeFillUser(t *testing.B) {
@@ -32,8 +32,8 @@ func BenchmarkNodeFillUser(t *testing.B) {
 		restic.NodeFromFileInfo(path, fi)
 	}
 
-	OK(t, tempfile.Close())
-	RemoveAll(t, tempfile.Name())
+	rtest.OK(t, tempfile.Close())
+	rtest.RemoveAll(t, tempfile.Name())
 }
 
 func BenchmarkNodeFromFileInfo(t *testing.B) {
@@ -58,8 +58,8 @@ func BenchmarkNodeFromFileInfo(t *testing.B) {
 		}
 	}
 
-	OK(t, tempfile.Close())
-	RemoveAll(t, tempfile.Name())
+	rtest.OK(t, tempfile.Close())
+	rtest.RemoveAll(t, tempfile.Name())
 }
 
 func parseTime(s string) time.Time {
@@ -166,12 +166,12 @@ var nodeTests = []restic.Node{
 }
 
 func TestNodeRestoreAt(t *testing.T) {
-	tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-")
-	OK(t, err)
+	tempdir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-")
+	rtest.OK(t, err)
 
 	defer func() {
-		if TestCleanupTempDirs {
-			RemoveAll(t, tempdir)
+		if rtest.TestCleanupTempDirs {
+			rtest.RemoveAll(t, tempdir)
 		} else {
 			t.Logf("leaving tempdir at %v", tempdir)
 		}
@@ -181,35 +181,35 @@ func TestNodeRestoreAt(t *testing.T) {
 
 	for _, test := range nodeTests {
 		nodePath := filepath.Join(tempdir, test.Name)
-		OK(t, test.CreateAt(context.TODO(), nodePath, nil, idx))
+		rtest.OK(t, test.CreateAt(context.TODO(), nodePath, nil, idx))
 
 		if test.Type == "symlink" && runtime.GOOS == "windows" {
 			continue
 		}
 		if test.Type == "dir" {
-			OK(t, test.RestoreTimestamps(nodePath))
+			rtest.OK(t, test.RestoreTimestamps(nodePath))
 		}
 
 		fi, err := os.Lstat(nodePath)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		n2, err := restic.NodeFromFileInfo(nodePath, fi)
-		OK(t, err)
+		rtest.OK(t, err)
 
-		Assert(t, test.Name == n2.Name,
+		rtest.Assert(t, test.Name == n2.Name,
 			"%v: name doesn't match (%v != %v)", test.Type, test.Name, n2.Name)
-		Assert(t, test.Type == n2.Type,
+		rtest.Assert(t, test.Type == n2.Type,
 			"%v: type doesn't match (%v != %v)", test.Type, test.Type, n2.Type)
-		Assert(t, test.Size == n2.Size,
+		rtest.Assert(t, test.Size == n2.Size,
 			"%v: size doesn't match (%v != %v)", test.Size, test.Size, n2.Size)
 
 		if runtime.GOOS != "windows" {
-			Assert(t, test.UID == n2.UID,
+			rtest.Assert(t, test.UID == n2.UID,
 				"%v: UID doesn't match (%v != %v)", test.Type, test.UID, n2.UID)
-			Assert(t, test.GID == n2.GID,
+			rtest.Assert(t, test.GID == n2.GID,
 				"%v: GID doesn't match (%v != %v)", test.Type, test.GID, n2.GID)
 			if test.Type != "symlink" {
-				Assert(t, test.Mode == n2.Mode,
+				rtest.Assert(t, test.Mode == n2.Mode,
 					"%v: mode doesn't match (0%o != 0%o)", test.Type, test.Mode, n2.Mode)
 			}
 		}
@@ -240,5 +240,5 @@ func AssertFsTimeEqual(t *testing.T, label string, nodeType string, t1 time.Time
 		equal = t1.Equal(t2)
 	}
 
-	Assert(t, equal, "%s: %s doesn't match (%v != %v)", label, nodeType, t1, t2)
+	rtest.Assert(t, equal, "%s: %s doesn't match (%v != %v)", label, nodeType, t1, t2)
 }
diff --git a/internal/restic/snapshot_test.go b/internal/restic/snapshot_test.go
index c02970ebb..5e1bf8822 100644
--- a/internal/restic/snapshot_test.go
+++ b/internal/restic/snapshot_test.go
@@ -5,12 +5,12 @@ import (
 	"time"
 
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 func TestNewSnapshot(t *testing.T) {
 	paths := []string{"/home/foobar"}
 
 	_, err := restic.NewSnapshot(paths, nil, "foo", time.Now())
-	OK(t, err)
+	rtest.OK(t, err)
 }
diff --git a/internal/restic/tree_test.go b/internal/restic/tree_test.go
index d0d08007b..d1cc8df91 100644
--- a/internal/restic/tree_test.go
+++ b/internal/restic/tree_test.go
@@ -10,7 +10,7 @@ import (
 
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 )
 
 var testFiles = []struct {
@@ -23,25 +23,25 @@ var testFiles = []struct {
 }
 
 func createTempDir(t *testing.T) string {
-	tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-")
-	OK(t, err)
+	tempdir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-")
+	rtest.OK(t, err)
 
 	for _, test := range testFiles {
 		file := filepath.Join(tempdir, test.name)
 		dir := filepath.Dir(file)
 		if dir != "." {
-			OK(t, os.MkdirAll(dir, 0755))
+			rtest.OK(t, os.MkdirAll(dir, 0755))
 		}
 
 		f, err := os.Create(file)
 		defer func() {
-			OK(t, f.Close())
+			rtest.OK(t, f.Close())
 		}()
 
-		OK(t, err)
+		rtest.OK(t, err)
 
 		_, err = f.Write(test.content)
-		OK(t, err)
+		rtest.OK(t, err)
 	}
 
 	return tempdir
@@ -50,8 +50,8 @@ func createTempDir(t *testing.T) string {
 func TestTree(t *testing.T) {
 	dir := createTempDir(t)
 	defer func() {
-		if TestCleanupTempDirs {
-			RemoveAll(t, dir)
+		if rtest.TestCleanupTempDirs {
+			rtest.RemoveAll(t, dir)
 		}
 	}()
 }
@@ -67,11 +67,11 @@ var testNodes = []restic.Node{
 func TestNodeMarshal(t *testing.T) {
 	for i, n := range testNodes {
 		data, err := json.Marshal(&n)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		var node restic.Node
 		err = json.Unmarshal(data, &node)
-		OK(t, err)
+		rtest.OK(t, err)
 
 		if n.Name != node.Name {
 			t.Fatalf("Node %d: Names are not equal, want: %q got: %q", i, n.Name, node.Name)
@@ -81,16 +81,16 @@ func TestNodeMarshal(t *testing.T) {
 
 func TestNodeComparison(t *testing.T) {
 	fi, err := os.Lstat("tree_test.go")
-	OK(t, err)
+	rtest.OK(t, err)
 
 	node, err := restic.NodeFromFileInfo("tree_test.go", fi)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	n2 := *node
-	Assert(t, node.Equals(n2), "nodes aren't equal")
+	rtest.Assert(t, node.Equals(n2), "nodes aren't equal")
 
 	n2.Size--
-	Assert(t, !node.Equals(n2), "nodes are equal")
+	rtest.Assert(t, !node.Equals(n2), "nodes are equal")
 }
 
 func TestLoadTree(t *testing.T) {
@@ -100,16 +100,16 @@ func TestLoadTree(t *testing.T) {
 	// save tree
 	tree := restic.NewTree()
 	id, err := repo.SaveTree(context.TODO(), tree)
-	OK(t, err)
+	rtest.OK(t, err)
 
 	// save packs
-	OK(t, repo.Flush())
+	rtest.OK(t, repo.Flush())
 
 	// load tree again
 	tree2, err := repo.LoadTree(context.TODO(), id)
-	OK(t, err)
+	rtest.OK(t, err)
 
-	Assert(t, tree.Equals(tree2),
+	rtest.Assert(t, tree.Equals(tree2),
 		"trees are not equal: want %v, got %v",
 		tree, tree2)
 }
diff --git a/internal/walk/walk_test.go b/internal/walk/walk_test.go
index 699000292..2e6d4f7cc 100644
--- a/internal/walk/walk_test.go
+++ b/internal/walk/walk_test.go
@@ -12,7 +12,7 @@ import (
 	"github.com/restic/restic/internal/pipe"
 	"github.com/restic/restic/internal/repository"
 	"github.com/restic/restic/internal/restic"
-	. "github.com/restic/restic/internal/test"
+	rtest "github.com/restic/restic/internal/test"
 	"github.com/restic/restic/internal/walk"
 )
 
@@ -20,16 +20,16 @@ func TestWalkTree(t *testing.T) {
 	repo, cleanup := repository.TestRepository(t)
 	defer cleanup()
 
-	dirs, err := filepath.Glob(TestWalkerPath)
-	OK(t, err)
+	dirs, err := filepath.Glob(rtest.TestWalkerPath)
+	rtest.OK(t, err)
 
 	// archive a few files
 	arch := archiver.New(repo)
 	sn, _, err := arch.Snapshot(context.TODO(), nil, dirs, nil, "localhost", nil, time.Now())
-	OK(t, err)
+	rtest.OK(t, err)
 
 	// flush repo, write all packs
-	OK(t, repo.Flush())
+	rtest.OK(t, repo.Flush())
 
 	// start tree walker
 	treeJobs := make(chan walk.TreeJob)
@@ -47,10 +47,10 @@ func TestWalkTree(t *testing.T) {
 	for {
 		// receive fs job
 		fsJob, fsChOpen := <-fsJobs
-		Assert(t, !fsChOpen || fsJob != nil,
+		rtest.Assert(t, !fsChOpen || fsJob != nil,
 			"received nil job from filesystem: %v %v", fsJob, fsChOpen)
 		if fsJob != nil {
-			OK(t, fsJob.Error())
+			rtest.OK(t, fsJob.Error())
 		}
 
 		var path string
@@ -67,13 +67,13 @@ func TestWalkTree(t *testing.T) {
 		treeJob, treeChOpen := <-treeJobs
 		treeEntries := 1
 
-		OK(t, treeJob.Error)
+		rtest.OK(t, treeJob.Error)
 
 		if treeJob.Tree != nil {
 			treeEntries = len(treeJob.Tree.Nodes)
 		}
 
-		Assert(t, fsChOpen == treeChOpen,
+		rtest.Assert(t, fsChOpen == treeChOpen,
 			"one channel closed too early: fsChOpen %v, treeChOpen %v",
 			fsChOpen, treeChOpen)
 
@@ -81,10 +81,10 @@ func TestWalkTree(t *testing.T) {
 			break
 		}
 
-		Assert(t, filepath.Base(path) == filepath.Base(treeJob.Path),
+		rtest.Assert(t, filepath.Base(path) == filepath.Base(treeJob.Path),
 			"paths do not match: %q != %q", filepath.Base(path), filepath.Base(treeJob.Path))
 
-		Assert(t, fsEntries == treeEntries,
+		rtest.Assert(t, fsEntries == treeEntries,
 			"wrong number of entries: %v != %v", fsEntries, treeEntries)
 	}
 }
@@ -1340,14 +1340,14 @@ var walktreeTestItems = []string{
 }
 
 func TestDelayedWalkTree(t *testing.T) {
-	repodir, cleanup := Env(t, repoFixture)
+	repodir, cleanup := rtest.Env(t, repoFixture)
 	defer cleanup()
 
 	repo := repository.TestOpenLocal(t, repodir)
-	OK(t, repo.LoadIndex(context.TODO()))
+	rtest.OK(t, repo.LoadIndex(context.TODO()))
 
 	root, err := restic.ParseID("937a2f64f736c64ee700c6ab06f840c68c94799c288146a0e81e07f4c94254da")
-	OK(t, err)
+	rtest.OK(t, err)
 
 	dr := delayRepo{repo, 100 * time.Millisecond}
 
@@ -1370,14 +1370,14 @@ func TestDelayedWalkTree(t *testing.T) {
 }
 
 func BenchmarkDelayedWalkTree(t *testing.B) {
-	repodir, cleanup := Env(t, repoFixture)
+	repodir, cleanup := rtest.Env(t, repoFixture)
 	defer cleanup()
 
 	repo := repository.TestOpenLocal(t, repodir)
-	OK(t, repo.LoadIndex(context.TODO()))
+	rtest.OK(t, repo.LoadIndex(context.TODO()))
 
 	root, err := restic.ParseID("937a2f64f736c64ee700c6ab06f840c68c94799c288146a0e81e07f4c94254da")
-	OK(t, err)
+	rtest.OK(t, err)
 
 	dr := delayRepo{repo, 10 * time.Millisecond}