use t.Context() instead of context.TODO() in tests

11 files changed, 188 insertions, 199 deletions

diff --git a/object_test.go b/object_test.go
index c0bb168..33ea442 100644
--- a/object_test.go
+++ b/object_test.go
@@ -19,7 +19,6 @@
 package schwift
 
 import (
-	"context"
 	"io"
 	"net/http"
 	"strings"
@@ -67,7 +66,7 @@ func TestObjectTempURLSha1Only(t *testing.T) {
 	})
 	must(t, err)
 
-	actualURL, err := account.Container("foo").Object("bar").TempURL(context.TODO(), "supersecretkey", http.MethodGet, time.Unix(1e9, 0))
+	actualURL, err := account.Container("foo").Object("bar").TempURL(t.Context(), "supersecretkey", http.MethodGet, time.Unix(1e9, 0))
 	must(t, err)
 
 	expectedURL := "https://example.com/v1/AUTH_example/foo/bar?temp_url_sig=ed44d92005345aee463c884d76d4850ef6d2778d&temp_url_expires=1000000000"
@@ -82,7 +81,7 @@ func TestObjectTempURL(t *testing.T) {
 	})
 	must(t, err)
 
-	actualURL, err := account.Container("foo").Object("bar").TempURL(context.TODO(), "supersecretkey", http.MethodGet, time.Unix(1e9, 0))
+	actualURL, err := account.Container("foo").Object("bar").TempURL(t.Context(), "supersecretkey", http.MethodGet, time.Unix(1e9, 0))
 	must(t, err)
 
 	expectedURL := "https://example.com/v1/AUTH_example/foo/bar?temp_url_sig=5fc94a988b502d83e88863774812636ef0133b8aae04b20366fd906bff41189f&temp_url_expires=1000000000"
diff --git a/tests/account_test.go b/tests/account_test.go
index d8b563d..1c5e8cc 100644
--- a/tests/account_test.go
+++ b/tests/account_test.go
@@ -19,7 +19,6 @@
 package tests
 
 import (
-	"context"
 	"testing"
 
 	"go.xyrillian.de/schwift/v2"
@@ -27,7 +26,7 @@ import (
 
 func TestAccountBasic(t *testing.T) {
 	testWithAccount(t, func(a *schwift.Account) {
-		hdr, err := a.Headers(context.TODO())
+		hdr, err := a.Headers(t.Context())
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
@@ -47,12 +46,12 @@ func TestAccountMetadata(t *testing.T) {
 		hdr := schwift.NewAccountHeaders()
 		hdr.Metadata().Set("schwift-test1", "first")
 		hdr.Metadata().Set("schwift-test2", "second")
-		err := a.Update(context.TODO(), hdr, nil)
+		err := a.Update(t.Context(), hdr, nil)
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
 
-		hdr, err = a.Headers(context.TODO())
+		hdr, err = a.Headers(t.Context())
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
@@ -62,12 +61,12 @@ func TestAccountMetadata(t *testing.T) {
 		// test deleting some metadata
 		hdr = schwift.NewAccountHeaders()
 		hdr.Metadata().Clear("schwift-test1")
-		err = a.Update(context.TODO(), hdr, nil)
+		err = a.Update(t.Context(), hdr, nil)
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
 
-		hdr, err = a.Headers(context.TODO())
+		hdr, err = a.Headers(t.Context())
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
@@ -79,12 +78,12 @@ func TestAccountMetadata(t *testing.T) {
 		hdr.Metadata().Set("schwift-test1", "will not be set")
 		hdr.Metadata().Del("schwift-test1")
 		hdr.Metadata().Set("schwift-test2", "changed")
-		err = a.Update(context.TODO(), hdr, nil)
+		err = a.Update(t.Context(), hdr, nil)
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
 
-		hdr, err = a.Headers(context.TODO())
+		hdr, err = a.Headers(t.Context())
 		if !expectSuccess(t, err) {
 			t.FailNow()
 		}
diff --git a/tests/bulk_delete_test.go b/tests/bulk_delete_test.go
index 2e5d909..33f249d 100644
--- a/tests/bulk_delete_test.go
+++ b/tests/bulk_delete_test.go
@@ -19,7 +19,6 @@
 package tests
 
 import (
-	"context"
 	"fmt"
 	"strings"
 	"testing"
@@ -31,28 +30,28 @@ import (
 func TestBulkDeleteSuccess(t *testing.T) {
 	testWithAccount(t, func(a *schwift.Account) {
 		testWithAndWithoutBulkDeleteSupport(func() {
-			c, err := a.Container("schwift-test-bulkdelete").EnsureExists(context.TODO())
+			c, err := a.Container("schwift-test-bulkdelete").EnsureExists(t.Context())
 			expectSuccess(t, err)
-			objs, err := createTestObjects(c)
+			objs, err := createTestObjects(t, c)
 			expectSuccess(t, err)
 
-			numDeleted, numNotFound, err := c.Account().BulkDelete(context.TODO(), objs, nil, nil)
+			numDeleted, numNotFound, err := c.Account().BulkDelete(t.Context(), objs, nil, nil)
 			expectSuccess(t, err)
 			expectInt(t, numDeleted, len(objs))
 			expectInt(t, numNotFound, 0)
 			expectContainerExistence(t, c, true)
 
-			numDeleted, numNotFound, err = c.Account().BulkDelete(context.TODO(), objs, nil, nil)
+			numDeleted, numNotFound, err = c.Account().BulkDelete(t.Context(), objs, nil, nil)
 			expectSuccess(t, err)
 			expectInt(t, numDeleted, 0)
 			expectInt(t, numNotFound, len(objs))
 			expectContainerExistence(t, c, true)
 
-			objs, err = createTestObjects(c)
+			objs, err = createTestObjects(t, c)
 			expectSuccess(t, err)
 			cs := []*schwift.Container{c}
 
-			numDeleted, numNotFound, err = c.Account().BulkDelete(context.TODO(), objs, cs, nil)
+			numDeleted, numNotFound, err = c.Account().BulkDelete(t.Context(), objs, cs, nil)
 			expectSuccess(t, err)
 			expectInt(t, numDeleted, len(objs)+1)
 			expectInt(t, numNotFound, 0)
@@ -64,7 +63,7 @@ func TestBulkDeleteSuccess(t *testing.T) {
 func TestBulkDeleteError(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		testWithAndWithoutBulkDeleteSupport(func() {
-			objs, err := createTestObjects(c)
+			objs, err := createTestObjects(t, c)
 			expectSuccess(t, err)
 			objs = objs[1:]
 			cs := []*schwift.Container{c}
@@ -72,7 +71,7 @@ func TestBulkDeleteError(t *testing.T) {
 			// not deleting all objects should lead to 409 Conflict when deleting the Container
 			// (NOTE: actual Swift returns 400 here although I don't understand why
 			// even after reading its code)
-			numDeleted, numNotFound, err := c.Account().BulkDelete(context.TODO(), objs, cs, nil)
+			numDeleted, numNotFound, err := c.Account().BulkDelete(t.Context(), objs, cs, nil)
 			expectInt(t, numDeleted, len(objs))
 			expectInt(t, numNotFound, 0)
 			t.Logf("err = %#v\n", err)
@@ -84,11 +83,11 @@ func TestBulkDeleteError(t *testing.T) {
 	})
 }
 
-func createTestObjects(c *schwift.Container) ([]*schwift.Object, error) {
+func createTestObjects(t *testing.T, c *schwift.Container) ([]*schwift.Object, error) {
 	var objs []*schwift.Object
 	for idx := 1; idx <= 5; idx++ {
 		obj := c.Object(fmt.Sprintf("object%d", idx))
-		err := obj.Upload(context.TODO(), strings.NewReader("example"), nil, nil)
+		err := obj.Upload(t.Context(), strings.NewReader("example"), nil, nil)
 		if err != nil {
 			return nil, err
 		}
diff --git a/tests/bulk_upload_test.go b/tests/bulk_upload_test.go
index 75420a5..ede3a65 100644
--- a/tests/bulk_upload_test.go
+++ b/tests/bulk_upload_test.go
@@ -21,7 +21,6 @@ package tests
 import (
 	"archive/tar"
 	"bytes"
-	"context"
 	"strings"
 	"testing"
 
@@ -39,7 +38,7 @@ func TestBulkUploadSuccess(t *testing.T) {
 			obj2.FullName(): []byte("world"),
 		})
 		n, err := c.Account().BulkUpload(
-			context.TODO(),
+			t.Context(),
 			"", // upload path
 			schwift.BulkUploadTar,
 			bytes.NewReader(archive),
@@ -58,7 +57,7 @@ func TestBulkUploadSuccess(t *testing.T) {
 func TestBulkUploadArchiveError(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		n, err := c.Account().BulkUpload(
-			context.TODO(),
+			t.Context(),
 			c.Name(), // upload path
 			schwift.BulkUploadTar,
 			strings.NewReader("This is not the TAR archive you're looking for."),
@@ -84,7 +83,7 @@ func TestBulkUploadObjectError(t *testing.T) {
 			obj2.Name(): []byte("world"),
 		})
 		n, err := c.Account().BulkUpload(
-			context.TODO(),
+			t.Context(),
 			c.Name(), // upload path
 			schwift.BulkUploadTar,
 			bytes.NewReader(archive),
diff --git a/tests/container_iterator_test.go b/tests/container_iterator_test.go
index 26feecf..113c3c5 100644
--- a/tests/container_iterator_test.go
+++ b/tests/container_iterator_test.go
@@ -19,7 +19,6 @@
 package tests
 
 import (
-	"context"
 	"fmt"
 	"testing"
 
@@ -34,52 +33,52 @@ func TestContainerIterator(t *testing.T) {
 
 		// create test containers that can be listed
 		for idx := 1; idx <= 4; idx++ {
-			_, err := a.Container(cname(idx)).EnsureExists(context.TODO())
+			_, err := a.Container(cname(idx)).EnsureExists(t.Context())
 			expectSuccess(t, err)
 		}
 
 		// test iteration with empty last page
 		iter := a.Containers()
 		iter.Prefix = "schwift-test-listing"
-		cs, err := iter.NextPage(context.TODO(), 2)
+		cs, err := iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs, cname(1), cname(2))
-		cs, err = iter.NextPage(context.TODO(), 2)
+		cs, err = iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs, cname(3), cname(4))
-		cs, err = iter.NextPage(context.TODO(), 2)
+		cs, err = iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs)
-		cs, err = iter.NextPage(context.TODO(), 2)
+		cs, err = iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs)
 
 		// test iteration with partial last page
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
-		cs, err = iter.NextPage(context.TODO(), 3)
+		cs, err = iter.NextPage(t.Context(), 3)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs, cname(1), cname(2), cname(3))
-		cs, err = iter.NextPage(context.TODO(), 3)
+		cs, err = iter.NextPage(t.Context(), 3)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs, cname(4))
-		cs, err = iter.NextPage(context.TODO(), 4)
+		cs, err = iter.NextPage(t.Context(), 4)
 		expectSuccess(t, err)
 		expectContainerNames(t, cs)
 
 		// test detailed iteration
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
-		cis, err := iter.NextPageDetailed(context.TODO(), 2)
+		cis, err := iter.NextPageDetailed(t.Context(), 2)
 		expectSuccess(t, err)
 		expectContainerInfos(t, cis, cname(1), cname(2))
-		cis, err = iter.NextPageDetailed(context.TODO(), 3)
+		cis, err = iter.NextPageDetailed(t.Context(), 3)
 		expectSuccess(t, err)
 		expectContainerInfos(t, cis, cname(3), cname(4))
-		cis, err = iter.NextPageDetailed(context.TODO(), 3)
+		cis, err = iter.NextPageDetailed(t.Context(), 3)
 		expectSuccess(t, err)
 		expectContainerInfos(t, cis)
-		cis, err = iter.NextPageDetailed(context.TODO(), 3)
+		cis, err = iter.NextPageDetailed(t.Context(), 3)
 		expectSuccess(t, err)
 		expectContainerInfos(t, cis)
 
@@ -88,7 +87,7 @@ func TestContainerIterator(t *testing.T) {
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
 		idx := 0
-		expectSuccess(t, iter.Foreach(context.TODO(), func(c *schwift.Container) error {
+		expectSuccess(t, iter.Foreach(t.Context(), func(c *schwift.Container) error {
 			idx++
 			expectString(t, c.Name(), cname(idx))
 			return nil
@@ -101,7 +100,7 @@ func TestContainerIterator(t *testing.T) {
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
 		idx = 0
-		expectSuccess(t, iter.ForeachDetailed(context.TODO(), func(info schwift.ContainerInfo) error {
+		expectSuccess(t, iter.ForeachDetailed(t.Context(), func(info schwift.ContainerInfo) error {
 			idx++
 			expectString(t, info.Container.Name(), cname(idx))
 			return nil
@@ -112,29 +111,29 @@ func TestContainerIterator(t *testing.T) {
 		// test Collect
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
-		cs, err = iter.Collect(context.TODO())
+		cs, err = iter.Collect(t.Context())
 		expectSuccess(t, err)
 		expectContainerNames(t, cs, cname(1), cname(2), cname(3), cname(4))
 
 		// test CollectDetailed
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
-		cis, err = iter.CollectDetailed(context.TODO())
+		cis, err = iter.CollectDetailed(t.Context())
 		expectSuccess(t, err)
 		expectContainerInfos(t, cis, cname(1), cname(2), cname(3), cname(4))
 
 		// cleanup
 		iter = a.Containers()
 		iter.Prefix = "schwift-test-listing"
-		expectSuccess(t, iter.Foreach(context.TODO(), func(c *schwift.Container) error {
-			return c.Delete(context.TODO(), nil)
+		expectSuccess(t, iter.Foreach(t.Context(), func(c *schwift.Container) error {
+			return c.Delete(t.Context(), nil)
 		}))
 	})
 }
 
 func expectAccountHeadersCached(t *testing.T, a *schwift.Account) {
 	requestCountBefore := a.Backend().(*RequestCountingBackend).Count
-	_, err := a.Headers(context.TODO())
+	_, err := a.Headers(t.Context())
 	expectSuccess(t, err)
 	requestCountAfter := a.Backend().(*RequestCountingBackend).Count
 
diff --git a/tests/container_test.go b/tests/container_test.go
index 192487b..caa98d1 100644
--- a/tests/container_test.go
+++ b/tests/container_test.go
@@ -19,7 +19,6 @@
 package tests
 
 import (
-	"context"
 	"fmt"
 	"net/http"
 	"testing"
@@ -37,35 +36,35 @@ func TestContainerLifecycle(t *testing.T) {
 			t.Errorf("expected c.Account() = %#v, got %#v instead\n", a, c.Account())
 		}
 
-		exists, err := c.Exists(context.TODO())
+		exists, err := c.Exists(t.Context())
 		expectSuccess(t, err)
 		expectBool(t, exists, false)
 
-		_, err = c.Headers(context.TODO())
+		_, err = c.Headers(t.Context())
 		expectError(t, err, fmt.Sprintf("could not HEAD %q in Swift: expected 204 response, got 404 instead", containerName))
 		expectBool(t, schwift.Is(err, http.StatusNotFound), true)
 		expectBool(t, schwift.Is(err, http.StatusNoContent), false)
 
 		// DELETE should be idempotent and not return success on non-existence, but
 		// OpenStack LOVES to be inconsistent with everything (including, notably, itself)
-		err = c.Delete(context.TODO(), nil)
+		err = c.Delete(t.Context(), nil)
 		expectError(t, err, fmt.Sprintf("could not DELETE %q in Swift: expected 204 response, got 404 instead: <html><h1>Not Found</h1><p>The resource could not be found.</p></html>", containerName))
 
-		err = c.Create(context.TODO(), nil)
+		err = c.Create(t.Context(), nil)
 		expectSuccess(t, err)
 
-		exists, err = c.Exists(context.TODO())
+		exists, err = c.Exists(t.Context())
 		expectSuccess(t, err)
 		expectBool(t, exists, true)
 
-		err = c.Delete(context.TODO(), nil)
+		err = c.Delete(t.Context(), nil)
 		expectSuccess(t, err)
 	})
 }
 
 func TestContainerUpdate(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
-		hdr, err := c.Headers(context.TODO())
+		hdr, err := c.Headers(t.Context())
 		expectSuccess(t, err)
 		expectBool(t, hdr.ObjectCount().Exists(), true)
 		expectUint64(t, hdr.ObjectCount().Get(), 0)
@@ -74,10 +73,10 @@ func TestContainerUpdate(t *testing.T) {
 		hdr.ObjectCountQuota().Set(23)
 		hdr.BytesUsedQuota().Set(42)
 
-		err = c.Update(context.TODO(), hdr, nil)
+		err = c.Update(t.Context(), hdr, nil)
 		expectSuccess(t, err)
 
-		hdr, err = c.Headers(context.TODO())
+		hdr, err = c.Headers(t.Context())
 		expectSuccess(t, err)
 		expectUint64(t, hdr.BytesUsedQuota().Get(), 42)
 		expectUint64(t, hdr.ObjectCountQuota().Get(), 23)
@@ -87,7 +86,7 @@ func TestContainerUpdate(t *testing.T) {
 func expectContainerExistence(t *testing.T, c *schwift.Container, expectedExists bool) {
 	t.Helper()
 	c.Invalidate()
-	actualExists, err := c.Exists(context.TODO())
+	actualExists, err := c.Exists(t.Context())
 	expectSuccess(t, err)
 	expectBool(t, actualExists, expectedExists)
 }
diff --git a/tests/field_test.go b/tests/field_test.go
index be09a17..5069be6 100644
--- a/tests/field_test.go
+++ b/tests/field_test.go
@@ -19,7 +19,6 @@
 package tests
 
 import (
-	"context"
 	"net/http"
 	"strconv"
 	"testing"
@@ -63,7 +62,7 @@ func TestFieldString(t *testing.T) {
 
 func TestFieldTimestamp(t *testing.T) {
 	testWithAccount(t, func(a *schwift.Account) {
-		hdr, err := a.Headers(context.TODO())
+		hdr, err := a.Headers(t.Context())
 		if !expectSuccess(t, err) {
 			return
 		}
@@ -89,12 +88,12 @@ func TestFieldTimestamp(t *testing.T) {
 func TestFieldHTTPTimestamp(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		obj := c.Object("test")
-		err := obj.Upload(context.TODO(), nil, nil, nil)
+		err := obj.Upload(t.Context(), nil, nil, nil)
 		if !expectSuccess(t, err) {
 			return
 		}
 
-		hdr, err := obj.Headers(context.TODO())
+		hdr, err := obj.Headers(t.Context())
 		if !expectSuccess(t, err) {
 			return
 		}
diff --git a/tests/largeobject_test.go b/tests/largeobject_test.go
index 9c7f093..d1ea6fb 100644
--- a/tests/largeobject_test.go
+++ b/tests/largeobject_test.go
@@ -20,7 +20,6 @@ package tests
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"strings"
 	"testing"
@@ -38,7 +37,7 @@ func TestLargeObjectsBasic(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		foreachLargeObjectStrategy(func(strategy schwift.LargeObjectStrategy, strategyStr string) {
 			obj := c.Object(strategyStr + "-largeobject")
-			_, err := obj.AsLargeObject(context.TODO())
+			_, err := obj.AsLargeObject(t.Context())
 			expectError(t, err, schwift.ErrNotLarge.Error())
 
 			segment1 := getRandomSegmentContent(128)
@@ -47,14 +46,14 @@ func TestLargeObjectsBasic(t *testing.T) {
 			segment4 := getRandomSegmentContent(128)
 
 			// basic write example
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    strategyStr + "-segments/",
 				Strategy:         strategy,
 			}, nil)
 			expectSuccess(t, err)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1+segment2)), 128, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1+segment2)), 128, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			expectObjectContent(t, obj, []byte(segment1+segment2))
 			expectLargeObject(t, obj, []schwift.SegmentInfo{
@@ -71,12 +70,12 @@ func TestLargeObjectsBasic(t *testing.T) {
 			})
 
 			// basic append example
-			lo, err = obj.AsLargeObject(context.TODO())
+			lo, err = obj.AsLargeObject(t.Context())
 			expectSuccess(t, err)
 			expectLargeObjectSetup(t, lo, strategy,
 				fmt.Sprintf("%s/%s-segments/", c.Name(), strategyStr))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment3+segment4)), 128, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment3+segment4)), 128, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			expectObjectContent(t, obj, []byte(segment1+segment2+segment3+segment4))
 			expectLargeObject(t, obj, []schwift.SegmentInfo{
@@ -103,9 +102,9 @@ func TestLargeObjectsBasic(t *testing.T) {
 			})
 
 			// basic truncate example
-			lo, err = obj.AsLargeObject(context.TODO())
+			lo, err = obj.AsLargeObject(t.Context())
 			expectSuccess(t, err)
-			err = lo.Truncate(context.TODO(), &schwift.TruncateOptions{
+			err = lo.Truncate(t.Context(), &schwift.TruncateOptions{
 				DeleteSegments: true,
 			})
 			expectSuccess(t, err)
@@ -115,12 +114,12 @@ func TestLargeObjectsBasic(t *testing.T) {
 			// verify that segments were deleted
 			iter := c.Objects()
 			iter.Prefix = lo.SegmentPrefix()
-			names, err := iter.Collect(context.TODO())
+			names, err := iter.Collect(t.Context())
 			expectSuccess(t, err)
 			expectObjectNames(t, names)
 
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment3+segment4)), 128, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment3+segment4)), 128, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			expectObjectContent(t, obj, []byte(segment3+segment4))
 			expectLargeObject(t, obj, []schwift.SegmentInfo{
@@ -144,7 +143,7 @@ func TestLargeObjectExpiration(t *testing.T) {
 		foreachLargeObjectStrategy(func(strategy schwift.LargeObjectStrategy, strategyStr string) {
 			segment := getRandomSegmentContent(128)
 			obj := c.Object(strategyStr + "-largeobject")
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    strategyStr + "-segments/",
 				Strategy:         strategy,
@@ -156,17 +155,17 @@ func TestLargeObjectExpiration(t *testing.T) {
 			headers := schwift.NewObjectHeaders()
 			headers.ExpiresAt().Set(expirationTime)
 
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment)), 128, headers.ToOpts()))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), headers.ToOpts()))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment)), 128, headers.ToOpts()))
+			expectSuccess(t, lo.WriteManifest(t.Context(), headers.ToOpts()))
 
 			// check object expiration
-			hdr, err := obj.Headers(context.TODO())
+			hdr, err := obj.Headers(t.Context())
 			expectSuccess(t, err)
 			objectExpiration := hdr.ExpiresAt().Get().Format("2006-01-02 15:04:05 +00:00 MST")
 			expectString(t, objectExpiration, expirationTime.Format("2006-01-02 15:04:05 +00:00 MST"))
 
 			// check segment expiration
-			hdr, err = c.Object(strategyStr + "-segments/0000000000000001").Headers(context.TODO())
+			hdr, err = c.Object(strategyStr + "-segments/0000000000000001").Headers(t.Context())
 			expectSuccess(t, err)
 			objectExpiration = hdr.ExpiresAt().Get().Format("2006-01-02 15:04:05 +00:00 MST")
 			expectString(t, objectExpiration, expirationTime.Format("2006-01-02 15:04:05 +00:00 MST"))
@@ -180,7 +179,7 @@ func TestTruncateDuringOverwrite(t *testing.T) {
 			obj := c.Object("largeobject")
 
 			// setup phase: create a large object
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    "segments/",
 				Strategy:         strategy,
@@ -189,24 +188,24 @@ func TestTruncateDuringOverwrite(t *testing.T) {
 
 			segment1 := getRandomSegmentContent(128)
 			segment2 := getRandomSegmentContent(128)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			expectObjectExistence(t, c.Object("segments/0000000000000001"), true)
 			expectObjectExistence(t, c.Object("segments/0000000000000002"), true)
 
 			// test phase: truncate using AsNewLargeObject
-			lo, err = obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err = obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				Strategy:         strategy,
 			}, &schwift.TruncateOptions{
 				DeleteSegments: true,
 			})
 			expectSuccess(t, err)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			expectObjectExistence(t, c.Object("segments/0000000000000001"), false)
 			expectObjectExistence(t, c.Object("segments/0000000000000002"), false)
@@ -217,8 +216,8 @@ func TestTruncateDuringOverwrite(t *testing.T) {
 func TestOpenRegularObjectAsLargeObject(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		o := c.Object("foo")
-		expectSuccess(t, o.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil))
-		_, err := o.AsLargeObject(context.TODO())
+		expectSuccess(t, o.Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, nil))
+		_, err := o.AsLargeObject(t.Context())
 		expectError(t, err, schwift.ErrNotLarge.Error())
 	})
 }
@@ -226,7 +225,7 @@ func TestOpenRegularObjectAsLargeObject(t *testing.T) {
 func TestSLOWithDataSegment(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		o := c.Object("foo")
-		lo, err := o.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+		lo, err := o.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 			SegmentContainer: c,
 			SegmentPrefix:    "segments/",
 			Strategy:         schwift.StaticLargeObject,
@@ -237,10 +236,10 @@ func TestSLOWithDataSegment(t *testing.T) {
 		dataSegment := schwift.SegmentInfo{Data: []byte("---")}
 		segment2 := getRandomSegmentContent(128)
 
-		expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+		expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
 		expectSuccess(t, lo.AddSegment(dataSegment))
-		expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-		expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+		expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+		expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 		expectObjectContent(t, o, []byte(segment1+string(dataSegment.Data)+segment2))
 		expectLargeObject(t, o, []schwift.SegmentInfo{
@@ -259,7 +258,7 @@ func TestSLOWithDataSegment(t *testing.T) {
 
 		// check that truncating this does not try to delete the nil segment.Object
 		// in the data segment
-		expectSuccess(t, lo.Truncate(context.TODO(), &schwift.TruncateOptions{
+		expectSuccess(t, lo.Truncate(t.Context(), &schwift.TruncateOptions{
 			DeleteSegments: true,
 		}))
 	})
@@ -269,10 +268,10 @@ func TestSLOWithRangeSegments(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		segmentStr := "<aaa>X<bbb>X<ccc>"
 		segmentObj := c.Object("segment")
-		expectSuccess(t, segmentObj.Upload(context.TODO(), bytes.NewReader([]byte(segmentStr)), nil, nil))
+		expectSuccess(t, segmentObj.Upload(t.Context(), bytes.NewReader([]byte(segmentStr)), nil, nil))
 
 		o := c.Object("largeobject")
-		lo, err := o.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+		lo, err := o.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 			SegmentContainer: c,
 			SegmentPrefix:    "segments/",
 			Strategy:         schwift.StaticLargeObject,
@@ -294,7 +293,7 @@ func TestSLOWithRangeSegments(t *testing.T) {
 			RangeOffset: -1,
 			RangeLength: 5,
 		}))
-		expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+		expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 		expectObjectContent(t, o, []byte(
 			strings.ReplaceAll(segmentStr, "X", ""),
@@ -329,7 +328,7 @@ func TestSLOGuessSegmentPrefix(t *testing.T) {
 		obj := c.Object("largeobject")
 
 		// setup phase: create an SLO
-		lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+		lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 			SegmentContainer: c,
 			SegmentPrefix:    "foo/bar/baz/",
 		}, nil)
@@ -337,12 +336,12 @@ func TestSLOGuessSegmentPrefix(t *testing.T) {
 
 		segment1 := getRandomSegmentContent(128)
 		segment2 := getRandomSegmentContent(128)
-		expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-		expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-		expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+		expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+		expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+		expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 		// now create a fresh SLO and check if it infers the correct SegmentPrefix
-		lo, err = obj.AsLargeObject(context.TODO())
+		lo, err = obj.AsLargeObject(t.Context())
 		expectSuccess(t, err)
 		expectString(t, lo.SegmentContainer().Name(), c.Name())
 		expectString(t, lo.SegmentPrefix(), "foo/bar/baz/")
@@ -355,7 +354,7 @@ func TestDeleteLargeObjectAndKeepSegments(t *testing.T) {
 			obj := c.Object("largeobject")
 
 			// setup phase: create a large object
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    "foo/bar/baz/",
 				Strategy:         strategy,
@@ -364,16 +363,16 @@ func TestDeleteLargeObjectAndKeepSegments(t *testing.T) {
 
 			segment1 := getRandomSegmentContent(128)
 			segment2 := getRandomSegmentContent(128)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			// test deletion that keeps segments
-			expectSuccess(t, obj.Delete(context.TODO(), nil, nil))
+			expectSuccess(t, obj.Delete(t.Context(), nil, nil))
 
 			iter := c.Objects()
 			iter.Prefix = lo.SegmentPrefix()
-			names, err := iter.Collect(context.TODO())
+			names, err := iter.Collect(t.Context())
 			expectSuccess(t, err)
 			expectObjectNames(t, names,
 				"foo/bar/baz/0000000000000001",
@@ -388,7 +387,7 @@ func TestDeleteLargeObjectIncludingSegments(t *testing.T) {
 			obj := c.Object("largeobject")
 
 			// setup phase: create a large object
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    "foo/bar/baz/",
 				Strategy:         strategy,
@@ -397,16 +396,16 @@ func TestDeleteLargeObjectIncludingSegments(t *testing.T) {
 
 			segment1 := getRandomSegmentContent(128)
 			segment2 := getRandomSegmentContent(128)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			// test deletion that keeps segments
-			expectSuccess(t, obj.Delete(context.TODO(), &schwift.DeleteOptions{DeleteSegments: true}, nil))
+			expectSuccess(t, obj.Delete(t.Context(), &schwift.DeleteOptions{DeleteSegments: true}, nil))
 
 			iter := c.Objects()
 			iter.Prefix = lo.SegmentPrefix()
-			names, err := iter.Collect(context.TODO())
+			names, err := iter.Collect(t.Context())
 			expectSuccess(t, err)
 			expectObjectNames(t, names)
 		})
@@ -419,7 +418,7 @@ func TestOverwriteLargeObjectAndKeepSegments(t *testing.T) {
 			obj := c.Object("largeobject")
 
 			// setup phase: create a large object
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    "foo/bar/baz/",
 				Strategy:         strategy,
@@ -428,16 +427,16 @@ func TestOverwriteLargeObjectAndKeepSegments(t *testing.T) {
 
 			segment1 := getRandomSegmentContent(128)
 			segment2 := getRandomSegmentContent(128)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			// test overwriting that keeps segments
-			expectSuccess(t, obj.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil))
+			expectSuccess(t, obj.Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, nil))
 
 			iter := c.Objects()
 			iter.Prefix = lo.SegmentPrefix()
-			names, err := iter.Collect(context.TODO())
+			names, err := iter.Collect(t.Context())
 			expectSuccess(t, err)
 			expectObjectNames(t, names,
 				"foo/bar/baz/0000000000000001",
@@ -452,7 +451,7 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
 			obj := c.Object("largeobject")
 
 			// setup phase: create a large object
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				SegmentPrefix:    "foo/bar/baz/",
 				Strategy:         strategy,
@@ -461,13 +460,13 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
 
 			segment1 := getRandomSegmentContent(128)
 			segment2 := getRandomSegmentContent(128)
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
-			expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
-			expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment1)), 0, nil))
+			expectSuccess(t, lo.Append(t.Context(), bytes.NewReader([]byte(segment2)), 0, nil))
+			expectSuccess(t, lo.WriteManifest(t.Context(), nil))
 
 			// test overwriting that deletes segments
 			expectSuccess(t, obj.Upload(
-				context.TODO(),
+				t.Context(),
 				bytes.NewReader(objectExampleContent),
 				&schwift.UploadOptions{DeleteSegments: true},
 				nil,
@@ -475,13 +474,13 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
 
 			iter := c.Objects()
 			iter.Prefix = lo.SegmentPrefix()
-			names, err := iter.Collect(context.TODO())
+			names, err := iter.Collect(t.Context())
 			expectSuccess(t, err)
 			expectObjectNames(t, names)
 
 			// test overwriting that wants to delete segments, but there aren't any
 			expectSuccess(t, obj.Upload(
-				context.TODO(),
+				t.Context(),
 				bytes.NewReader(objectExampleContent),
 				&schwift.UploadOptions{DeleteSegments: true},
 				nil,
@@ -489,7 +488,7 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
 
 			// while we're at it, test the same for deletion
 			expectSuccess(t, obj.Delete(
-				context.TODO(),
+				t.Context(),
 				&schwift.DeleteOptions{DeleteSegments: true},
 				nil,
 			))
@@ -501,7 +500,7 @@ func TestAddInvalidSegments(t *testing.T) {
 	foreachLargeObjectStrategy(func(strategy schwift.LargeObjectStrategy, strategyStr string) {
 		testWithContainer(t, func(c *schwift.Container) {
 			obj := c.Object("largeobject")
-			lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
+			lo, err := obj.AsNewLargeObject(t.Context(), schwift.SegmentingOptions{
 				SegmentContainer: c,
 				Strategy:         strategy,
 			}, nil)
@@ -570,7 +569,7 @@ func TestAddInvalidSegments(t *testing.T) {
 func expectLargeObject(t *testing.T, obj *schwift.Object, expected []schwift.SegmentInfo) {
 	t.Helper()
 	expectObjectExistence(t, obj, true)
-	lo, err := obj.AsLargeObject(context.TODO())
+	lo, err := obj.AsLargeObject(t.Context())
 	expectSuccess(t, err)
 	if lo == nil {
 		t.FailNow()
diff --git a/tests/object_iterator_test.go b/tests/object_iterator_test.go
index 592d896..751efc8 100644
--- a/tests/object_iterator_test.go
+++ b/tests/object_iterator_test.go
@@ -20,7 +20,6 @@ package tests
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"strings"
 	"testing"
@@ -41,52 +40,52 @@ func TestObjectIterator(t *testing.T) {
 		for idx := 1; idx <= 4; idx++ {
 			hdr := schwift.NewObjectHeaders()
 			hdr.ContentType().Set("application/json")
-			err := c.Object(oname(idx)).Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
+			err := c.Object(oname(idx)).Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
 			expectSuccess(t, err)
 		}
 
 		// test iteration with empty last page
 		iter := c.Objects()
 		iter.Prefix = "schwift-test-listing"
-		os, err := iter.NextPage(context.TODO(), 2)
+		os, err := iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectObjectNames(t, os, oname(1), oname(2))
-		os, err = iter.NextPage(context.TODO(), 2)
+		os, err = iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectObjectNames(t, os, oname(3), oname(4))
-		os, err = iter.NextPage(context.TODO(), 2)
+		os, err = iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectObjectNames(t, os)
-		os, err = iter.NextPage(context.TODO(), 2)
+		os, err = iter.NextPage(t.Context(), 2)
 		expectSuccess(t, err)
 		expectObjectNames(t, os)
 
 		// test iteration with partial last page
 		iter = c.Objects()
 		iter.Prefix = "schwift-test-listing"
-		os, err = iter.NextPage(context.TODO(), 3)
+		os, err = iter.NextPage(t.Context(), 3)
 		expectSuccess(t, err)
 		expectObjectNames(t, os, oname(1), oname(2), oname(3))
-		os, err = iter.NextPage(context.TODO(), 3)
+		os, err = iter.NextPage(t.Context(), 3)
 		expectSuccess(t, err)
 		expectObjectNames(t, os, oname(4))
-		os, err = iter.NextPage(context.TODO(), 4)
+		os, err = iter.NextPage(t.Context(), 4)
 		expectSuccess(t, err)
 		expectObjectNames(t, os)
 
 		// test detailed iteration
 		iter = c.Objects()
 		iter.Prefix = "schwift-test-listing"
-		ois, err := iter.NextPageDetailed(context.TODO(), 2)
+		ois, err := iter.NextPageDetailed(t.Context(), 2)
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois, oname(1), oname(2))
-		ois, err = iter.NextPageDetailed(context.TODO(), 3)
+		ois, err = iter.NextPageDetailed(t.Context(), 3)
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois, oname(3), oname(4))
-		ois, err = iter.NextPageDetailed(context.TODO(), 3)
+		ois, err = iter.NextPageDetailed(t.Context(), 3)
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois)
-		ois, err = iter.NextPageDetailed(context.TODO(), 3)
+		ois, err = iter.NextPageDetailed(t.Context(), 3)
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois)
 
@@ -95,7 +94,7 @@ func TestObjectIterator(t *testing.T) {
 		iter = c.Objects()
 		iter.Prefix = "schwift-test-listing"
 		idx := 0
-		expectSuccess(t, iter.Foreach(context.TODO(), func(o *schwift.Object) error {
+		expectSuccess(t, iter.Foreach(t.Context(), func(o *schwift.Object) error {
 			idx++
 			expectString(t, o.Name(), oname(idx))
 			return nil
@@ -108,7 +107,7 @@ func TestObjectIterator(t *testing.T) {
 		iter = c.Objects()
 		iter.Prefix = "schwift-test-listing"
 		idx = 0
-		expectSuccess(t, iter.ForeachDetailed(context.TODO(), func(info schwift.ObjectInfo) error {
+		expectSuccess(t, iter.ForeachDetailed(t.Context(), func(info schwift.ObjectInfo) error {
 			idx++
 			expectString(t, info.Object.Name(), oname(idx))
 			return nil
@@ -119,14 +118,14 @@ func TestObjectIterator(t *testing.T) {
 		// test Collect
 		iter = c.Objects()
 		iter.Prefix = "schwift-test-listing"
-		os, err = iter.Collect(context.TODO())
+		os, err = iter.Collect(t.Context())
 		expectSuccess(t, err)
 		expectObjectNames(t, os, oname(1), oname(2), oname(3), oname(4))
 
 		// test CollectDetailed
 		iter = c.Objects()
 		iter.Prefix = "schwift-test-listing"
-		ois, err = iter.CollectDetailed(context.TODO())
+		ois, err = iter.CollectDetailed(t.Context())
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois, oname(1), oname(2), oname(3), oname(4))
 	})
@@ -147,20 +146,20 @@ func TestPseudoDirectories(t *testing.T) {
 		for _, name := range objectNames {
 			hdr := schwift.NewObjectHeaders()
 			hdr.ContentType().Set("application/json")
-			err := c.Object(name).Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
+			err := c.Object(name).Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
 			expectSuccess(t, err)
 		}
 
 		// test iteration with Delimiter and no Prefix
 		iter := c.Objects()
 		iter.Delimiter = "/"
-		os, err := iter.Collect(context.TODO())
+		os, err := iter.Collect(t.Context())
 		expectSuccess(t, err)
 		expectObjectNames(t, os, "foo/")
 
 		iter = c.Objects()
 		iter.Delimiter = "/"
-		ois, err := iter.CollectDetailed(context.TODO())
+		ois, err := iter.CollectDetailed(t.Context())
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois, "subdir:foo/")
 
@@ -168,14 +167,14 @@ func TestPseudoDirectories(t *testing.T) {
 		iter = c.Objects()
 		iter.Prefix = "foo/"
 		iter.Delimiter = "/"
-		os, err = iter.Collect(context.TODO())
+		os, err = iter.Collect(t.Context())
 		expectSuccess(t, err)
 		expectObjectNames(t, os, "foo/1", "foo/2", "foo/3", "foo/bar", "foo/bar/")
 
 		iter = c.Objects()
 		iter.Prefix = "foo/"
 		iter.Delimiter = "/"
-		ois, err = iter.CollectDetailed(context.TODO())
+		ois, err = iter.CollectDetailed(t.Context())
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois, "foo/1", "foo/2", "foo/3", "foo/bar", "subdir:foo/bar/")
 	})
@@ -191,20 +190,20 @@ func TestObjectIteratorWithSymlinks(t *testing.T) {
 		for _, name := range objectNames {
 			hdr := schwift.NewObjectHeaders()
 			hdr.ContentType().Set("application/json")
-			err := c.Object(name).Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
+			err := c.Object(name).Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
 			expectSuccess(t, err)
 		}
 
 		// create a test symlink
-		expectSuccess(t, c.Object("foo/2").SymlinkTo(context.TODO(), c.Object("foo/1"), nil, nil))
+		expectSuccess(t, c.Object("foo/2").SymlinkTo(t.Context(), c.Object("foo/1"), nil, nil))
 
 		iter := c.Objects()
-		os, err := iter.Collect(context.TODO())
+		os, err := iter.Collect(t.Context())
 		expectSuccess(t, err)
 		expectObjectNames(t, os, "foo/1", "foo/2", "foo/3")
 
 		iter = c.Objects()
-		ois, err := iter.CollectDetailed(context.TODO())
+		ois, err := iter.CollectDetailed(t.Context())
 		expectSuccess(t, err)
 		expectObjectInfos(t, ois, "foo/1", "symlink:foo/2>foo/1", "foo/3")
 	})
@@ -212,7 +211,7 @@ func TestObjectIteratorWithSymlinks(t *testing.T) {
 
 func expectContainerHeadersCached(t *testing.T, c *schwift.Container) {
 	requestCountBefore := c.Account().Backend().(*RequestCountingBackend).Count
-	_, err := c.Headers(context.TODO())
+	_, err := c.Headers(t.Context())
 	expectSuccess(t, err)
 	requestCountAfter := c.Account().Backend().(*RequestCountingBackend).Count
 
diff --git a/tests/object_test.go b/tests/object_test.go
index dd1b4c2..541a843 100644
--- a/tests/object_test.go
+++ b/tests/object_test.go
@@ -20,7 +20,6 @@ package tests
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"io"
 	"net/http"
@@ -42,22 +41,22 @@ func TestObjectLifecycle(t *testing.T) {
 		}
 		expectObjectExistence(t, o, false)
 
-		_, err := o.Headers(context.TODO())
+		_, err := o.Headers(t.Context())
 		expectError(t, err, fmt.Sprintf("could not HEAD %q in Swift: expected 200 response, got 404 instead", o.FullName()))
 		expectBool(t, schwift.Is(err, http.StatusNotFound), true)
 		expectBool(t, schwift.Is(err, http.StatusNoContent), false)
 
 		// DELETE should be idempotent and not return success on non-existence, but
 		// OpenStack LOVES to be inconsistent with everything (including, notably, itself)
-		err = o.Delete(context.TODO(), nil, nil)
+		err = o.Delete(t.Context(), nil, nil)
 		expectError(t, err, fmt.Sprintf("could not DELETE %q in Swift: expected 204 response, got 404 instead: <html><h1>Not Found</h1><p>The resource could not be found.</p></html>", o.FullName()))
 
-		err = o.Upload(context.TODO(), bytes.NewReader([]byte("test")), nil, nil)
+		err = o.Upload(t.Context(), bytes.NewReader([]byte("test")), nil, nil)
 		expectSuccess(t, err)
 
 		expectObjectExistence(t, o, true)
 
-		err = o.Delete(context.TODO(), nil, nil)
+		err = o.Delete(t.Context(), nil, nil)
 		expectSuccess(t, err)
 	})
 }
@@ -66,31 +65,31 @@ func TestObjectUpload(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		// test upload with bytes.Reader
 		obj := c.Object("upload1")
-		err := obj.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
+		err := obj.Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, nil)
 		expectSuccess(t, err)
 		expectObjectContent(t, obj, objectExampleContent)
 
 		// test upload with bytes.Buffer
 		obj = c.Object("upload2")
-		err = obj.Upload(context.TODO(), bytes.NewBuffer(objectExampleContent), nil, nil)
+		err = obj.Upload(t.Context(), bytes.NewBuffer(objectExampleContent), nil, nil)
 		expectSuccess(t, err)
 		expectObjectContent(t, obj, objectExampleContent)
 
 		// test upload with strings.Reader
 		obj = c.Object("upload3")
-		err = obj.Upload(context.TODO(), strings.NewReader(string(objectExampleContent)), nil, nil)
+		err = obj.Upload(t.Context(), strings.NewReader(string(objectExampleContent)), nil, nil)
 		expectSuccess(t, err)
 		expectObjectContent(t, obj, objectExampleContent)
 
 		// test upload with opaque io.Reader
 		obj = c.Object("upload4")
-		err = obj.Upload(context.TODO(), opaqueReader{bytes.NewReader(objectExampleContent)}, nil, nil)
+		err = obj.Upload(t.Context(), opaqueReader{bytes.NewReader(objectExampleContent)}, nil, nil)
 		expectSuccess(t, err)
 		expectObjectContent(t, obj, objectExampleContent)
 
 		// test upload with io.Writer
 		obj = c.Object("upload5")
-		err = obj.UploadFromWriter(context.TODO(), nil, nil, func(w io.Writer) error {
+		err = obj.UploadFromWriter(t.Context(), nil, nil, func(w io.Writer) error {
 			_, err := w.Write(objectExampleContent)
 			return err
 		})
@@ -99,13 +98,13 @@ func TestObjectUpload(t *testing.T) {
 
 		// test upload with empty reader (should create zero-byte-sized object)
 		obj = c.Object("upload6")
-		err = obj.Upload(context.TODO(), eofReader{}, nil, nil)
+		err = obj.Upload(t.Context(), eofReader{}, nil, nil)
 		expectSuccess(t, err)
 		expectObjectContent(t, obj, nil)
 
 		// test upload without reader (should create zero-byte-sized object)
 		obj = c.Object("upload7")
-		err = obj.Upload(context.TODO(), nil, nil, nil)
+		err = obj.Upload(t.Context(), nil, nil, nil)
 		expectSuccess(t, err)
 		expectObjectContent(t, obj, nil)
 	})
@@ -129,21 +128,21 @@ func TestObjectDownload(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		// upload example object
 		obj := c.Object("example")
-		err := obj.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
+		err := obj.Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, nil)
 		expectSuccess(t, err)
 
 		// test download as string
-		str, err := obj.Download(context.TODO(), nil).AsString()
+		str, err := obj.Download(t.Context(), nil).AsString()
 		expectSuccess(t, err)
 		expectString(t, str, string(objectExampleContent))
 
 		// test download as byte slice
-		buf, err := obj.Download(context.TODO(), nil).AsByteSlice()
+		buf, err := obj.Download(t.Context(), nil).AsByteSlice()
 		expectSuccess(t, err)
 		expectString(t, string(buf), string(objectExampleContent))
 
 		// test download as io.ReadCloser slice
-		reader, err := obj.Download(context.TODO(), nil).AsReadCloser()
+		reader, err := obj.Download(t.Context(), nil).AsReadCloser()
 		expectSuccess(t, err)
 		buf = make([]byte, 4)
 		_, err = reader.Read(buf)
@@ -165,23 +164,23 @@ func TestObjectUpdate(t *testing.T) {
 		// test that metadata update fails for non-existing object
 		newHeaders := schwift.NewObjectHeaders()
 		newHeaders.ContentType().Set("application/json")
-		err := obj.Update(context.TODO(), newHeaders, nil)
+		err := obj.Update(t.Context(), newHeaders, nil)
 		expectBool(t, schwift.Is(err, http.StatusNotFound), true)
 		expectError(t, err, fmt.Sprintf("could not POST %q in Swift: expected 202 response, got 404 instead: <html><h1>Not Found</h1><p>The resource could not be found.</p></html>", obj.FullName()))
 
 		// create object
-		err = obj.Upload(context.TODO(), nil, nil, nil)
+		err = obj.Upload(t.Context(), nil, nil, nil)
 		expectSuccess(t, err)
 
-		hdr, err := obj.Headers(context.TODO())
+		hdr, err := obj.Headers(t.Context())
 		expectSuccess(t, err)
 		expectString(t, hdr.ContentType().Get(), "application/octet-stream")
 
 		// now the metadata update should work
-		err = obj.Update(context.TODO(), newHeaders, nil)
+		err = obj.Update(t.Context(), newHeaders, nil)
 		expectSuccess(t, err)
 		obj.Invalidate()
-		hdr, err = obj.Headers(context.TODO())
+		hdr, err = obj.Headers(t.Context())
 		expectSuccess(t, err)
 		expectString(t, hdr.ContentType().Get(), "application/json")
 	})
@@ -190,12 +189,12 @@ func TestObjectUpdate(t *testing.T) {
 func TestObjectCopy(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		obj1 := c.Object("location1")
-		err := obj1.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
+		err := obj1.Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, nil)
 		expectSuccess(t, err)
 		expectObjectExistence(t, obj1, true)
 
 		obj2 := c.Object("location2")
-		expectSuccess(t, obj1.CopyTo(context.TODO(), obj2, nil, nil))
+		expectSuccess(t, obj1.CopyTo(t.Context(), obj2, nil, nil))
 		expectObjectExistence(t, obj1, true)
 		expectObjectExistence(t, obj2, true)
 		expectObjectContent(t, obj2, objectExampleContent)
@@ -206,39 +205,39 @@ func TestSymlinkOperations(t *testing.T) {
 	testWithContainer(t, func(c *schwift.Container) {
 		// create a test object that we can link to
 		obj1 := c.Object("target")
-		err := obj1.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
+		err := obj1.Upload(t.Context(), bytes.NewReader(objectExampleContent), nil, nil)
 		expectSuccess(t, err)
 		expectObjectExistence(t, obj1, true)
 
 		// create a symlink
 		obj2 := c.Object("symlink")
-		expectSuccess(t, obj2.SymlinkTo(context.TODO(), obj1, nil, nil))
+		expectSuccess(t, obj2.SymlinkTo(t.Context(), obj1, nil, nil))
 		expectObjectExistence(t, obj2, true)
 		expectObjectSymlink(t, obj2, obj1)
 		expectObjectContent(t, obj2, objectExampleContent)
 
 		// overwrite symlink with normal object
 		otherContent := []byte("abc")
-		expectSuccess(t, obj2.Upload(context.TODO(), bytes.NewReader(otherContent), nil, nil))
+		expectSuccess(t, obj2.Upload(t.Context(), bytes.NewReader(otherContent), nil, nil))
 		expectObjectExistence(t, obj2, true)
 		expectObjectSymlink(t, obj2, nil)
 		expectObjectContent(t, obj2, otherContent)
 
 		// overwrite normal object with symlink
-		expectSuccess(t, obj2.SymlinkTo(context.TODO(), obj1, nil, nil))
+		expectSuccess(t, obj2.SymlinkTo(t.Context(), obj1, nil, nil))
 		expectObjectExistence(t, obj2, true)
 		expectObjectSymlink(t, obj2, obj1)
 		expectObjectContent(t, obj2, objectExampleContent)
 
 		// deep-copy symlink
 		obj3 := c.Object("copy")
-		expectSuccess(t, obj2.CopyTo(context.TODO(), obj3, nil, nil))
+		expectSuccess(t, obj2.CopyTo(t.Context(), obj3, nil, nil))
 		expectObjectExistence(t, obj3, true)
 		expectObjectSymlink(t, obj3, nil)
 		expectObjectContent(t, obj3, objectExampleContent)
 
 		// shallow-copy symlink
-		expectSuccess(t, obj2.CopyTo(context.TODO(), obj3, &schwift.CopyOptions{
+		expectSuccess(t, obj2.CopyTo(t.Context(), obj3, &schwift.CopyOptions{
 			ShallowCopySymlinks: true,
 		}, nil))
 		expectObjectExistence(t, obj3, true)
@@ -246,7 +245,7 @@ func TestSymlinkOperations(t *testing.T) {
 		expectObjectContent(t, obj3, objectExampleContent)
 
 		// delete symlink
-		expectSuccess(t, obj2.Delete(context.TODO(), nil, nil))
+		expectSuccess(t, obj2.Delete(t.Context(), nil, nil))
 		expectObjectExistence(t, obj2, false)
 	})
 }
@@ -257,18 +256,18 @@ func TestSymlinkOperations(t *testing.T) {
 func expectObjectExistence(t *testing.T, obj *schwift.Object, expectedExists bool) {
 	t.Helper()
 	obj.Invalidate()
-	actualExists, err := obj.Exists(context.TODO())
+	actualExists, err := obj.Exists(t.Context())
 	expectSuccess(t, err)
 	expectBool(t, actualExists, expectedExists)
 }
 
 func expectObjectContent(t *testing.T, obj *schwift.Object, expected []byte) {
 	t.Helper()
-	str, err := obj.Download(context.TODO(), nil).AsString()
+	str, err := obj.Download(t.Context(), nil).AsString()
 	expectSuccess(t, err)
 	expectString(t, str, string(expected))
 	obj.Invalidate()
-	hdr, err := obj.Headers(context.TODO())
+	hdr, err := obj.Headers(t.Context())
 	expectSuccess(t, err)
 	if !hdr.IsLargeObject() {
 		expectString(t, hdr.Etag().Get(), etagOf(expected))
@@ -277,7 +276,7 @@ func expectObjectContent(t *testing.T, obj *schwift.Object, expected []byte) {
 
 func expectObjectSymlink(t *testing.T, source, expectedTarget *schwift.Object) {
 	t.Helper()
-	_, target, err := source.SymlinkHeaders(context.TODO())
+	_, target, err := source.SymlinkHeaders(t.Context())
 	if expectedTarget == nil {
 		switch err {
 		case nil:
diff --git a/tests/shared_test.go b/tests/shared_test.go
index 4bef612..9ff9053 100644
--- a/tests/shared_test.go
+++ b/tests/shared_test.go
@@ -19,7 +19,6 @@
 package tests
 
 import (
-	"context"
 	"crypto/md5" //nolint:gosec // Etag uses md5
 	"crypto/rand"
 	"encoding/hex"
@@ -44,7 +43,7 @@ func testWithAccount(t *testing.T, testCode func(a *schwift.Account)) {
 
 	if stAuth == "" && stUser == "" && stKey == "" {
 		// option 1: Keystone authentication
-		provider, err := clientconfig.AuthenticatedClient(context.TODO(), nil)
+		provider, err := clientconfig.AuthenticatedClient(t.Context(), nil)
 		if err != nil {
 			t.Error("clientconfig.AuthenticatedClient returned: " + err.Error())
 			t.Error("probably missing Swift credentials (need either ST_AUTH, ST_USER, ST_KEY or OS_* variables)")
@@ -62,7 +61,7 @@ func testWithAccount(t *testing.T, testCode func(a *schwift.Account)) {
 			t.Error("openstack.NewClient returned: " + err.Error())
 			return
 		}
-		client, err = swauth.NewObjectStorageV1(context.TODO(), provider, swauth.AuthOpts{User: stUser, Key: stKey})
+		client, err = swauth.NewObjectStorageV1(t.Context(), provider, swauth.AuthOpts{User: stUser, Key: stKey})
 		if err != nil {
 			t.Error("swauth.NewObjectStorageV1 returned: " + err.Error())
 			return
@@ -87,19 +86,19 @@ func testWithAccount(t *testing.T, testCode func(a *schwift.Account)) {
 func testWithContainer(t *testing.T, testCode func(c *schwift.Container)) {
 	testWithAccount(t, func(a *schwift.Account) {
 		containerName := getRandomName()
-		container, err := a.Container(containerName).EnsureExists(context.TODO())
+		container, err := a.Container(containerName).EnsureExists(t.Context())
 		expectSuccess(t, err)
 
 		testCode(container)
 
 		// cleanup
-		exists, err := container.Exists(context.TODO())
+		exists, err := container.Exists(t.Context())
 		expectSuccess(t, err)
 		if exists {
-			expectSuccess(t, container.Objects().Foreach(context.TODO(), func(o *schwift.Object) error {
-				return o.Delete(context.TODO(), nil, nil)
+			expectSuccess(t, container.Objects().Foreach(t.Context(), func(o *schwift.Object) error {
+				return o.Delete(t.Context(), nil, nil)
 			}))
-			err = container.Delete(context.TODO(), nil)
+			err = container.Delete(t.Context(), nil)
 			expectSuccess(t, err)
 		}
 	})