diff --git a/client_test.go b/client_test.go
index 2b6b89fd5..db80a9c30 100644
--- a/client_test.go
+++ b/client_test.go
@@ -184,7 +184,6 @@ func TestImagePull(t *testing.T) {
 	defer cancel()
 	_, err = client.Pull(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 }
diff --git a/container_checkpoint_test.go b/container_checkpoint_test.go
index 6144ca075..18373f28f 100644
--- a/container_checkpoint_test.go
+++ b/container_checkpoint_test.go
@@ -27,66 +27,55 @@ func TestCheckpointRestore(t *testing.T) {
 
 	image, err := client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(oci.WithImageConfig(image), oci.WithProcessArgs("sleep", "100")), WithNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	checkpoint, err := task.Checkpoint(ctx, WithExit)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	<-statusC
 
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if task, err = container.NewTask(ctx, empty(), WithTaskCheckpoint(checkpoint)); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err = task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 }
@@ -107,74 +96,61 @@ func TestCheckpointRestoreNewContainer(t *testing.T) {
 
 	image, err := client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(oci.WithImageConfig(image), oci.WithProcessArgs("sleep", "100")), WithNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	checkpoint, err := task.Checkpoint(ctx, WithExit)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	<-statusC
 
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := container.Delete(ctx, WithSnapshotCleanup); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if container, err = client.NewContainer(ctx, id, WithCheckpoint(checkpoint, id)); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if task, err = container.NewTask(ctx, empty(), WithTaskCheckpoint(checkpoint)); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err = task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 }
@@ -200,52 +176,43 @@ func TestCheckpointLeaveRunning(t *testing.T) {
 
 	image, err := client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(oci.WithImageConfig(image), oci.WithProcessArgs("sleep", "100")), WithNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if _, err := task.Checkpoint(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	status, err := task.Status(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if status.Status != Running {
-		t.Errorf("expected status %q but received %q", Running, status)
-		return
+		t.Fatalf("expected status %q but received %q", Running, status)
 	}
 
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	<-statusC
diff --git a/container_linux_test.go b/container_linux_test.go
index b7d648fba..82e3a9a1a 100644
--- a/container_linux_test.go
+++ b/container_linux_test.go
@@ -43,8 +43,7 @@ func TestTaskUpdate(t *testing.T) {
 
 	image, err := client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	limit := int64(32 * 1024 * 1024)
 	memory := func(_ context.Context, _ oci.Client, _ *containers.Container, s *specs.Spec) error {
@@ -57,38 +56,32 @@ func TestTaskUpdate(t *testing.T) {
 		WithNewSpec(oci.WithImageConfig(image), withProcessArgs("sleep", "30"), memory),
 		WithNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// check that the task has a limit of 32mb
 	cgroup, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(task.Pid())))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	stat, err := cgroup.Stat(cgroups.IgnoreNotExist)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if int64(stat.Memory.Usage.Limit) != limit {
-		t.Errorf("expected memory limit to be set to %d but received %d", limit, stat.Memory.Usage.Limit)
-		return
+		t.Fatalf("expected memory limit to be set to %d but received %d", limit, stat.Memory.Usage.Limit)
 	}
 	limit = 64 * 1024 * 1024
 	if err := task.Update(ctx, WithResources(&specs.LinuxResources{
@@ -100,15 +93,13 @@ func TestTaskUpdate(t *testing.T) {
 	}
 	// check that the task has a limit of 64mb
 	if stat, err = cgroup.Stat(cgroups.IgnoreNotExist); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if int64(stat.Memory.Usage.Limit) != limit {
 		t.Errorf("expected memory limit to be set to %d but received %d", limit, stat.Memory.Usage.Limit)
 	}
 	if err := task.Kill(ctx, unix.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	<-statusC
@@ -131,21 +122,18 @@ func TestShimInCgroup(t *testing.T) {
 
 	image, err := client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(oci.WithImageConfig(image), oci.WithProcessArgs("sleep", "30")), WithNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 	// create a cgroup for the shim to use
 	path := "/containerd/shim"
 	cg, err := cgroups.New(cgroups.V1, cgroups.StaticPath(path), &specs.LinuxResources{})
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer cg.Delete()
 
@@ -156,29 +144,25 @@ func TestShimInCgroup(t *testing.T) {
 		return nil
 	})
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// check to see if the shim is inside the cgroup
 	processes, err := cg.Processes(cgroups.Devices, false)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if len(processes) == 0 {
 		t.Errorf("created cgroup should have atleast one process inside: %d", len(processes))
 	}
 	if err := task.Kill(ctx, unix.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	<-statusC
@@ -200,33 +184,28 @@ func TestDaemonRestart(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "30")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	var exitStatus ExitStatus
@@ -249,8 +228,7 @@ func TestDaemonRestart(t *testing.T) {
 
 	statusC, err = task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
@@ -285,14 +263,12 @@ func TestContainerAttach(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withCat()), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
@@ -300,8 +276,7 @@ func TestContainerAttach(t *testing.T) {
 
 	direct, err := newDirectIO(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer direct.Delete()
 	var (
@@ -316,8 +291,7 @@ func TestContainerAttach(t *testing.T) {
 
 	task, err := container.NewTask(ctx, direct.IOCreate)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
@@ -327,8 +301,7 @@ func TestContainerAttach(t *testing.T) {
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if _, err := fmt.Fprint(direct.Stdin, expected); err != nil {
@@ -337,13 +310,11 @@ func TestContainerAttach(t *testing.T) {
 
 	// load the container and re-load the task
 	if container, err = client.LoadContainer(ctx, id); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if task, err = container.Task(ctx, direct.IOAttach); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if _, err := fmt.Fprint(direct.Stdin, expected); err != nil {
@@ -437,13 +408,11 @@ func TestContainerUsername(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	direct, err := newDirectIO(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer direct.Delete()
 	var (
@@ -462,27 +431,23 @@ func TestContainerUsername(t *testing.T) {
 		WithNewSpec(withImageConfig(image), oci.WithUsername("squid"), oci.WithProcessArgs("id", "-u")),
 	)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, direct.IOCreate)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 
@@ -519,14 +484,12 @@ func TestContainerAttachProcess(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
@@ -535,8 +498,7 @@ func TestContainerAttachProcess(t *testing.T) {
 	// creating IO early for easy resource cleanup
 	direct, err := newDirectIO(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer direct.Delete()
 	var (
@@ -551,8 +513,7 @@ func TestContainerAttachProcess(t *testing.T) {
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
@@ -562,14 +523,12 @@ func TestContainerAttachProcess(t *testing.T) {
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	processSpec := spec.Process
@@ -577,18 +536,15 @@ func TestContainerAttachProcess(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, direct.IOCreate)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	processStatusC, err := process.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := process.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if _, err := fmt.Fprint(direct.Stdin, expected); err != nil {
@@ -596,8 +552,7 @@ func TestContainerAttachProcess(t *testing.T) {
 	}
 
 	if process, err = task.LoadProcess(ctx, execID, direct.IOAttach); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if _, err := fmt.Fprint(direct.Stdin, expected); err != nil {
@@ -646,13 +601,11 @@ func TestContainerUserID(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	direct, err := newDirectIO(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer direct.Delete()
 	var (
@@ -671,27 +624,23 @@ func TestContainerUserID(t *testing.T) {
 		WithNewSpec(withImageConfig(image), oci.WithUserID(3), oci.WithProcessArgs("sh", "-c", "echo $(id -u):$(id -g)")),
 	)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, direct.IOCreate)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 
@@ -721,8 +670,7 @@ func TestContainerKillAll(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(ctx, id,
@@ -733,28 +681,24 @@ func TestContainerKillAll(t *testing.T) {
 		),
 	)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	stdout := bytes.NewBuffer(nil)
 	task, err := container.NewTask(ctx, cio.NewCreator(withByteBuffers(stdout)))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Kill(ctx, syscall.SIGKILL, WithKillAll); err != nil {
@@ -763,8 +707,7 @@ func TestContainerKillAll(t *testing.T) {
 
 	<-statusC
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 }
 
@@ -848,8 +791,7 @@ func TestDaemonRestartWithRunningShim(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(oci.WithImageConfig(image), oci.WithProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
@@ -930,8 +872,7 @@ func TestContainerRuntimeOptions(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(
@@ -941,8 +882,7 @@ func TestContainerRuntimeOptions(t *testing.T) {
 		WithRuntime("io.containerd.runtime.v1.linux", &runctypes.RuncOptions{Runtime: "no-runc"}),
 	)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
@@ -973,8 +913,7 @@ func TestContainerKillInitPidHost(t *testing.T) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(ctx, id,
@@ -985,28 +924,24 @@ func TestContainerKillInitPidHost(t *testing.T) {
 		),
 	)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	stdout := bytes.NewBuffer(nil)
 	task, err := container.NewTask(ctx, cio.NewCreator(withByteBuffers(stdout)))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
@@ -1069,8 +1004,7 @@ func testUserNamespaces(t *testing.T, readonlyRootFS bool) {
 
 	image, err = client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	opts := []NewContainerOpts{WithNewSpec(withImageConfig(image),
@@ -1085,8 +1019,7 @@ func testUserNamespaces(t *testing.T, readonlyRootFS bool) {
 
 	container, err := client.NewContainer(ctx, id, opts...)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
@@ -1098,15 +1031,13 @@ func testUserNamespaces(t *testing.T, readonlyRootFS bool) {
 		return nil
 	})
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if pid := task.Pid(); pid <= 0 {
@@ -1120,16 +1051,14 @@ func testUserNamespaces(t *testing.T, readonlyRootFS bool) {
 	status := <-statusC
 	code, _, err := status.Result()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if code != 7 {
 		t.Errorf("expected status 7 from wait but received %d", code)
 	}
 	deleteStatus, err := task.Delete(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if ec := deleteStatus.ExitCode(); ec != 7 {
 		t.Errorf("expected status 7 from delete but received %d", ec)
@@ -1155,32 +1084,27 @@ func TestTaskResize(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withExitStatus(7)), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := task.Resize(ctx, 32, 32); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	task.Kill(ctx, syscall.SIGKILL)
 	<-statusC
@@ -1201,14 +1125,12 @@ func TestContainerImage(t *testing.T) {
 
 	image, err := client.GetImage(ctx, testImage)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(), WithImage(image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
@@ -1236,8 +1158,7 @@ func TestContainerNoImage(t *testing.T) {
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
diff --git a/container_test.go b/container_test.go
index 8513b0469..d3ed29ee7 100644
--- a/container_test.go
+++ b/container_test.go
@@ -45,8 +45,7 @@ func TestContainerList(t *testing.T) {
 
 	containers, err := client.Containers(ctx)
 	if err != nil {
-		t.Errorf("container list returned error %v", err)
-		return
+		t.Fatalf("container list returned error %v", err)
 	}
 	if len(containers) != 0 {
 		t.Errorf("expected 0 containers but received %d", len(containers))
@@ -68,20 +67,17 @@ func TestNewContainer(t *testing.T) {
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 	if container.ID() != id {
 		t.Errorf("expected container id %q but received %q", id, container.ID())
 	}
 	if _, err = container.Spec(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := container.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 }
 
@@ -104,28 +100,24 @@ func TestContainerStart(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withExitStatus(7)), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if pid := task.Pid(); pid <= 0 {
@@ -139,8 +131,7 @@ func TestContainerStart(t *testing.T) {
 	status := <-statusC
 	code, _, err := status.Result()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if code != 7 {
 		t.Errorf("expected status 7 from wait but received %d", code)
@@ -148,8 +139,7 @@ func TestContainerStart(t *testing.T) {
 
 	deleteStatus, err := task.Delete(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if ec := deleteStatus.ExitCode(); ec != 7 {
 		t.Errorf("expected status 7 from delete but received %d", ec)
@@ -176,34 +166,29 @@ func TestContainerOutput(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("echo", expected)), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	stdout := bytes.NewBuffer(nil)
 	task, err := container.NewTask(ctx, cio.NewCreator(withByteBuffers(stdout)))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	status := <-statusC
@@ -212,8 +197,7 @@ func TestContainerOutput(t *testing.T) {
 		t.Errorf("expected status 0 but received %d: %v", code, err)
 	}
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	actual := stdout.String()
@@ -252,39 +236,33 @@ func TestContainerExec(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	finishedC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// start an exec process without running the original container process info
@@ -293,26 +271,22 @@ func TestContainerExec(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	processStatusC, err := process.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := process.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// wait for the exec to return
 	status := <-processStatusC
 	code, _, err := status.Result()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if code != 6 {
@@ -320,8 +294,7 @@ func TestContainerExec(t *testing.T) {
 	}
 	deleteStatus, err := process.Delete(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if ec := deleteStatus.ExitCode(); ec != 6 {
 		t.Errorf("expected delete exit code 6 but received %d", ec)
@@ -350,39 +323,33 @@ func TestContainerLargeExecArgs(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	finishedC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	processSpec := spec.Process
@@ -390,29 +357,24 @@ func TestContainerLargeExecArgs(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	processStatusC, err := process.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := process.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// wait for the exec to return
 	status := <-processStatusC
 	if _, _, err := status.Result(); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if _, err := process.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
 		t.Error(err)
@@ -439,34 +401,29 @@ func TestContainerPids(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	pid := task.Pid()
@@ -475,8 +432,7 @@ func TestContainerPids(t *testing.T) {
 	}
 	processes, err := task.Pids(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	switch runtime.GOOS {
 	case "windows":
@@ -524,15 +480,13 @@ func TestContainerCloseIO(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withCat()), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
@@ -540,26 +494,22 @@ func TestContainerCloseIO(t *testing.T) {
 
 	r, w, err := os.Pipe()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	task, err := container.NewTask(ctx, cio.NewCreator(cio.WithStreams(r, stdout, ioutil.Discard)))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	w.Close()
 	if err := task.CloseIO(ctx, WithStdinCloser); err != nil {
@@ -588,34 +538,29 @@ func TestDeleteRunningContainer(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	err = container.Delete(ctx, WithSnapshotCleanup)
@@ -626,8 +571,7 @@ func TestDeleteRunningContainer(t *testing.T) {
 		t.Errorf("expected error %q but received %q", errdefs.ErrFailedPrecondition, err)
 	}
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 }
@@ -651,45 +595,38 @@ func TestContainerKill(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "10")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 
 	err = task.Kill(ctx, syscall.SIGTERM)
 	if err == nil {
-		t.Error("second call to kill should return an error")
-		return
+		t.Fatal("second call to kill should return an error")
 	}
 	if !errdefs.IsNotFound(err) {
 		t.Errorf("expected error %q but received %q", errdefs.ErrNotFound, err)
@@ -715,8 +652,7 @@ func TestContainerNoBinaryExists(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
@@ -724,8 +660,7 @@ func TestContainerNoBinaryExists(t *testing.T) {
 		WithNewSpec(withImageConfig(image), oci.WithProcessArgs("nothing")),
 		withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
@@ -766,22 +701,19 @@ func TestContainerExecNoBinaryExists(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
@@ -790,13 +722,11 @@ func TestContainerExecNoBinaryExists(t *testing.T) {
 		t.Error(err)
 	}
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// start an exec process without running the original container process
@@ -807,8 +737,7 @@ func TestContainerExecNoBinaryExists(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer process.Delete(ctx)
 	if err := process.Start(ctx); err == nil {
@@ -839,29 +768,25 @@ func TestWaitStoppedTask(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withExitStatus(7)), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if pid := task.Pid(); pid <= 0 {
@@ -877,14 +802,12 @@ func TestWaitStoppedTask(t *testing.T) {
 	<-statusC
 	statusC, err = task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	status := <-statusC
 	code, _, err := status.Result()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if code != 7 {
 		t.Errorf("exit status from stopped task should be 7 but received %d", code)
@@ -910,22 +833,19 @@ func TestWaitStoppedProcess(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
@@ -935,13 +855,11 @@ func TestWaitStoppedProcess(t *testing.T) {
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// start an exec process without running the original container process info
@@ -950,20 +868,17 @@ func TestWaitStoppedProcess(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer process.Delete(ctx)
 
 	statusC, err := process.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := process.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// wait for the exec to return
@@ -972,14 +887,12 @@ func TestWaitStoppedProcess(t *testing.T) {
 	// try to wait on the process after it has stopped
 	statusC, err = process.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	status := <-statusC
 	code, _, err := status.Result()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if code != 6 {
 		t.Errorf("exit status from stopped process should be 6 but received %d", code)
@@ -1010,32 +923,27 @@ func TestTaskForceDelete(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "30")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if _, err := task.Delete(ctx); err == nil {
 		t.Error("task.Delete of a running task should create an error")
 	}
 	if _, err := task.Delete(ctx, WithProcessKill); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 }
 
@@ -1058,39 +966,33 @@ func TestProcessForceDelete(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "30")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// task must be started on windows
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	processSpec := spec.Process
@@ -1098,12 +1000,10 @@ func TestProcessForceDelete(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := process.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if _, err := process.Delete(ctx); err == nil {
 		t.Error("process.Delete should return an error when process is running")
@@ -1112,8 +1012,7 @@ func TestProcessForceDelete(t *testing.T) {
 		t.Error(err)
 	}
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 }
@@ -1138,8 +1037,7 @@ func TestContainerHostname(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
@@ -1149,42 +1047,36 @@ func TestContainerHostname(t *testing.T) {
 	),
 		withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	stdout := bytes.NewBuffer(nil)
 	task, err := container.NewTask(ctx, cio.NewCreator(withByteBuffers(stdout)))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	status := <-statusC
 	code, _, err := status.Result()
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if code != 0 {
 		t.Errorf("expected status 0 but received %d", code)
 	}
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	cutset := "\n"
 	if runtime.GOOS == "windows" {
@@ -1216,22 +1108,19 @@ func TestContainerExitedAtSet(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withTrue()), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
@@ -1242,8 +1131,7 @@ func TestContainerExitedAtSet(t *testing.T) {
 
 	startTime := time.Now()
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	status := <-statusC
@@ -1259,8 +1147,7 @@ func TestContainerExitedAtSet(t *testing.T) {
 	}
 
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 }
 
@@ -1283,22 +1170,19 @@ func TestDeleteContainerExecCreated(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec(withImageConfig(image), withProcessArgs("sleep", "100")), withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
@@ -1308,13 +1192,11 @@ func TestDeleteContainerExecCreated(t *testing.T) {
 	}
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	// start an exec process without running the original container process info
@@ -1323,13 +1205,11 @@ func TestDeleteContainerExecCreated(t *testing.T) {
 	execID := t.Name() + "_exec"
 	process, err := task.Exec(ctx, execID, processSpec, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	deleteStatus, err := process.Delete(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if ec := deleteStatus.ExitCode(); ec != 0 {
 		t.Errorf("expected delete exit code 0 but received %d", ec)
@@ -1362,30 +1242,26 @@ func TestContainerMetrics(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id,
 		WithNewSpec(withImageConfig(image), oci.WithProcessArgs("sleep", "30")),
 		withNewSnapshot(id, image))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	metric, err := task.Metrics(ctx)
@@ -1396,8 +1272,7 @@ func TestContainerMetrics(t *testing.T) {
 		t.Errorf("expected metric id %q but received %q", id, metric.ID)
 	}
 	if err := task.Kill(ctx, syscall.SIGKILL); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	<-statusC
@@ -1425,8 +1300,7 @@ func TestDeletedContainerMetrics(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		image, err = client.GetImage(ctx, testImage)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 	}
 	container, err := client.NewContainer(ctx, id,
@@ -1434,33 +1308,28 @@ func TestDeletedContainerMetrics(t *testing.T) {
 		withNewSnapshot(id, image),
 	)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx, WithSnapshotCleanup)
 
 	task, err := container.NewTask(ctx, empty())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer task.Delete(ctx)
 
 	if err := task.Start(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	statusC, err := task.Wait(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	<-statusC
 
 	if _, err := task.Delete(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	if _, err := task.Metrics(ctx); err == nil {
@@ -1484,16 +1353,14 @@ func TestContainerExtensions(t *testing.T) {
 	ext := gogotypes.Any{TypeUrl: "test.ext.url", Value: []byte("hello")}
 	container, err := client.NewContainer(ctx, id, WithNewSpec(), WithContainerExtension("hello", &ext))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
 	checkExt := func(container Container) {
 		cExts, err := container.Extensions(ctx)
 		if err != nil {
-			t.Error(err)
-			return
+			t.Fatal(err)
 		}
 		if len(cExts) != 1 {
 			t.Errorf("expected 1 container extension")
@@ -1510,8 +1377,7 @@ func TestContainerExtensions(t *testing.T) {
 
 	container, err = client.LoadContainer(ctx, container.ID())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	checkExt(container)
 }
@@ -1531,15 +1397,13 @@ func TestContainerUpdate(t *testing.T) {
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
 	spec, err := container.Spec(ctx)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 
 	const hostname = "updated-hostname"
@@ -1553,12 +1417,10 @@ func TestContainerUpdate(t *testing.T) {
 		c.Spec = a
 		return nil
 	}); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if spec, err = container.Spec(ctx); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if spec.Hostname != hostname {
 		t.Errorf("hostname %q != %q", spec.Hostname, hostname)
@@ -1580,8 +1442,7 @@ func TestContainerInfo(t *testing.T) {
 
 	container, err := client.NewContainer(ctx, id, WithNewSpec())
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
@@ -1611,8 +1472,7 @@ func TestContainerLabels(t *testing.T) {
 		"test": "yes",
 	}))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer container.Delete(ctx)
 
diff --git a/metadata/gc_test.go b/metadata/gc_test.go
index 3382e267b..05754b39d 100644
--- a/metadata/gc_test.go
+++ b/metadata/gc_test.go
@@ -316,8 +316,7 @@ func checkNodesEqual(t *testing.T, n1, n2 []gc.Node) {
 	sort.Sort(nodeList(n2))
 
 	if len(n1) != len(n2) {
-		t.Errorf("Nodes do not match\n\tExpected:\n\t%v\n\tActual:\n\t%v", n2, n1)
-		return
+		t.Fatalf("Nodes do not match\n\tExpected:\n\t%v\n\tActual:\n\t%v", n2, n1)
 	}
 
 	for i := range n1 {
diff --git a/snapshots/overlay/overlay_test.go b/snapshots/overlay/overlay_test.go
index 7083e3212..c5e5cd77c 100644
--- a/snapshots/overlay/overlay_test.go
+++ b/snapshots/overlay/overlay_test.go
@@ -41,13 +41,11 @@ func TestOverlayMounts(t *testing.T) {
 	defer os.RemoveAll(root)
 	o, _, err := newSnapshotter(ctx, root)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	mounts, err := o.Prepare(ctx, "/tmp/test", "")
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if len(mounts) != 1 {
 		t.Errorf("should only have 1 mount but received %d", len(mounts))
@@ -77,23 +75,19 @@ func TestOverlayCommit(t *testing.T) {
 	defer os.RemoveAll(root)
 	o, _, err := newSnapshotter(ctx, root)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	key := "/tmp/test"
 	mounts, err := o.Prepare(ctx, key, "")
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	m := mounts[0]
 	if err := ioutil.WriteFile(filepath.Join(m.Source, "foo"), []byte("hi"), 0660); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := o.Commit(ctx, "base", key); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 }
 
@@ -106,22 +100,18 @@ func TestOverlayOverlayMount(t *testing.T) {
 	defer os.RemoveAll(root)
 	o, _, err := newSnapshotter(ctx, root)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	key := "/tmp/test"
 	if _, err = o.Prepare(ctx, key, ""); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := o.Commit(ctx, "base", key); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	var mounts []mount.Mount
 	if mounts, err = o.Prepare(ctx, "/tmp/layer2", "base"); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if len(mounts) != 1 {
 		t.Errorf("should only have 1 mount but received %d", len(mounts))
@@ -194,46 +184,37 @@ func TestOverlayOverlayRead(t *testing.T) {
 	defer os.RemoveAll(root)
 	o, _, err := newSnapshotter(ctx, root)
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	key := "/tmp/test"
 	mounts, err := o.Prepare(ctx, key, "")
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	m := mounts[0]
 	if err := ioutil.WriteFile(filepath.Join(m.Source, "foo"), []byte("hi"), 0660); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := o.Commit(ctx, "base", key); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if mounts, err = o.Prepare(ctx, "/tmp/layer2", "base"); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	dest := filepath.Join(root, "dest")
 	if err := os.Mkdir(dest, 0700); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if err := mount.All(mounts, dest); err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	defer syscall.Unmount(dest, 0)
 	data, err := ioutil.ReadFile(filepath.Join(dest, "foo"))
 	if err != nil {
-		t.Error(err)
-		return
+		t.Fatal(err)
 	}
 	if e := string(data); e != "hi" {
-		t.Errorf("expected file contents hi but got %q", e)
-		return
+		t.Fatalf("expected file contents hi but got %q", e)
 	}
 }