*: Lint

1 files changed, 63 insertions, 12 deletions

diff --git a/objectstore/packed/read_test.go b/objectstore/packed/read_test.go
index 9bfa6610..9ba89fdf 100644
--- a/objectstore/packed/read_test.go
+++ b/objectstore/packed/read_test.go
@@ -30,16 +30,20 @@ func TestPackedStoreReadAgainstGit(t *testing.T) {
 				if err != nil {
 					t.Fatalf("ReadHeader: %v", err)
 				}
+
 				if gotHeaderType != wantType {
 					t.Fatalf("ReadHeader type = %v, want %v", gotHeaderType, wantType)
 				}
+
 				if gotHeaderSize != int64(len(wantBody)) {
 					t.Fatalf("ReadHeader size = %d, want %d", gotHeaderSize, len(wantBody))
 				}
+
 				gotSize, err := store.ReadSize(id)
 				if err != nil {
 					t.Fatalf("ReadSize: %v", err)
 				}
+
 				if gotSize != int64(len(wantBody)) {
 					t.Fatalf("ReadSize = %d, want %d", gotSize, len(wantBody))
 				}
@@ -48,6 +52,7 @@ func TestPackedStoreReadAgainstGit(t *testing.T) {
 				if err != nil {
 					t.Fatalf("ReadBytesFull: %v", err)
 				}
+
 				if !bytes.Equal(gotRaw, wantRaw) {
 					t.Fatalf("ReadBytesFull mismatch")
 				}
@@ -56,9 +61,11 @@ func TestPackedStoreReadAgainstGit(t *testing.T) {
 				if err != nil {
 					t.Fatalf("ReadBytesContent: %v", err)
 				}
+
 				if gotType != wantType {
 					t.Fatalf("ReadBytesContent type = %v, want %v", gotType, wantType)
 				}
+
 				if !bytes.Equal(gotBody, wantBody) {
 					t.Fatalf("ReadBytesContent mismatch")
 				}
@@ -67,7 +74,9 @@ func TestPackedStoreReadAgainstGit(t *testing.T) {
 				if err != nil {
 					t.Fatalf("ReadReaderFull: %v", err)
 				}
-				if got := mustReadAllAndClose(t, fullReader); !bytes.Equal(got, wantRaw) {
+
+				got := mustReadAllAndClose(t, fullReader)
+				if !bytes.Equal(got, wantRaw) {
 					t.Fatalf("ReadReaderFull mismatch")
 				}
 
@@ -75,13 +84,17 @@ func TestPackedStoreReadAgainstGit(t *testing.T) {
 				if err != nil {
 					t.Fatalf("ReadReaderContent: %v", err)
 				}
+
 				if contentType != wantType {
 					t.Fatalf("ReadReaderContent type = %v, want %v", contentType, wantType)
 				}
+
 				if contentSize != int64(len(wantBody)) {
 					t.Fatalf("ReadReaderContent size = %d, want %d", contentSize, len(wantBody))
 				}
-				if got := mustReadAllAndClose(t, contentReader); !bytes.Equal(got, wantBody) {
+
+				got = mustReadAllAndClose(t, contentReader)
+				if !bytes.Equal(got, wantBody) {
 					t.Fatalf("ReadReaderContent mismatch")
 				}
 			})
@@ -100,38 +113,54 @@ func TestPackedStoreErrors(t *testing.T) {
 			t.Fatalf("ParseHex(notFound): %v", err)
 		}
 
-		if _, err := store.ReadBytesFull(notFoundID); !errors.Is(err, objectstore.ErrObjectNotFound) {
+		_, err = store.ReadBytesFull(notFoundID)
+		if !errors.Is(err, objectstore.ErrObjectNotFound) {
 			t.Fatalf("ReadBytesFull not-found error = %v", err)
 		}
-		if _, _, err := store.ReadBytesContent(notFoundID); !errors.Is(err, objectstore.ErrObjectNotFound) {
+
+		_, _, err = store.ReadBytesContent(notFoundID)
+		if !errors.Is(err, objectstore.ErrObjectNotFound) {
 			t.Fatalf("ReadBytesContent not-found error = %v", err)
 		}
-		if _, err := store.ReadReaderFull(notFoundID); !errors.Is(err, objectstore.ErrObjectNotFound) {
+
+		_, err = store.ReadReaderFull(notFoundID)
+		if !errors.Is(err, objectstore.ErrObjectNotFound) {
 			t.Fatalf("ReadReaderFull not-found error = %v", err)
 		}
-		if _, _, _, err := store.ReadReaderContent(notFoundID); !errors.Is(err, objectstore.ErrObjectNotFound) {
+
+		_, _, _, err = store.ReadReaderContent(notFoundID)
+		if !errors.Is(err, objectstore.ErrObjectNotFound) {
 			t.Fatalf("ReadReaderContent not-found error = %v", err)
 		}
-		if _, _, err := store.ReadHeader(notFoundID); !errors.Is(err, objectstore.ErrObjectNotFound) {
+
+		_, _, err = store.ReadHeader(notFoundID)
+		if !errors.Is(err, objectstore.ErrObjectNotFound) {
 			t.Fatalf("ReadHeader not-found error = %v", err)
 		}
-		if _, err := store.ReadSize(notFoundID); !errors.Is(err, objectstore.ErrObjectNotFound) {
+
+		_, err = store.ReadSize(notFoundID)
+		if !errors.Is(err, objectstore.ErrObjectNotFound) {
 			t.Fatalf("ReadSize not-found error = %v", err)
 		}
 
 		var otherAlgo objectid.Algorithm
+
 		for _, candidate := range objectid.SupportedAlgorithms() {
 			if candidate != algo {
 				otherAlgo = candidate
+
 				break
 			}
 		}
+
 		if otherAlgo != objectid.AlgorithmUnknown {
 			mismatchID, err := objectid.ParseHex(otherAlgo, strings.Repeat("0", otherAlgo.HexLen()))
 			if err != nil {
 				t.Fatalf("ParseHex(mismatch): %v", err)
 			}
-			if _, err := store.ReadBytesFull(mismatchID); err == nil || !strings.Contains(err.Error(), "algorithm mismatch") {
+
+			_, err = store.ReadBytesFull(mismatchID)
+			if err == nil || !strings.Contains(err.Error(), "algorithm mismatch") {
 				t.Fatalf("ReadBytesFull algorithm-mismatch error = %v", err)
 			}
 		}
@@ -141,11 +170,16 @@ func TestPackedStoreErrors(t *testing.T) {
 func TestPackedStoreNewValidation(t *testing.T) {
 	t.Parallel()
 	testRepo, _ := createPackedFixtureRepo(t, objectid.AlgorithmSHA1)
+
 	store := openPackedStore(t, testRepo.Dir(), objectid.AlgorithmSHA1)
-	if err := store.Close(); err != nil {
+
+	err := store.Close()
+	if err != nil {
 		t.Fatalf("Close: %v", err)
 	}
-	if err := store.Close(); err != nil {
+
+	err = store.Close()
+	if err != nil {
 		t.Fatalf("Close second: %v", err)
 	}
 }
@@ -153,13 +187,16 @@ func TestPackedStoreNewValidation(t *testing.T) {
 func TestPackedStoreInvalidAlgorithm(t *testing.T) {
 	t.Parallel()
 	testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: objectid.AlgorithmSHA1, Bare: true})
+
 	root, err := os.OpenRoot(testRepo.Dir())
 	if err != nil {
 		t.Fatalf("OpenRoot(%q): %v", testRepo.Dir(), err)
 	}
+
 	t.Cleanup(func() { _ = root.Close() })
 
-	if _, err := packed.New(root, objectid.AlgorithmUnknown); !errors.Is(err, objectid.ErrInvalidAlgorithm) {
+	_, err = packed.New(root, objectid.AlgorithmUnknown)
+	if !errors.Is(err, objectid.ErrInvalidAlgorithm) {
 		t.Fatalf("packed.New invalid algorithm error = %v", err)
 	}
 }
@@ -170,15 +207,20 @@ func TestPackedStoreReadHeaderUsesResolvedObjectSizeForDelta(t *testing.T) {
 		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
 
 		var parent objectid.ObjectID
+
 		for i := range 96 {
 			content := strings.Repeat("common-line-"+strconv.Itoa(i%7)+"\n", 384) + fmt.Sprintf("tail-%03d\n", i)
+
 			_, treeID := testRepo.MakeSingleFileTree(t, "file.txt", []byte(content))
 			if i == 0 {
 				parent = testRepo.CommitTree(t, treeID, "delta-header-size-0")
+
 				continue
 			}
+
 			parent = testRepo.CommitTree(t, treeID, fmt.Sprintf("delta-header-size-%03d", i), parent)
 		}
+
 		testRepo.UpdateRef(t, "refs/heads/main", parent)
 		testRepo.Repack(t, "-a", "-d", "-f", "--window=128", "--depth=128")
 
@@ -189,13 +231,16 @@ func TestPackedStoreReadHeaderUsesResolvedObjectSizeForDelta(t *testing.T) {
 		if err != nil {
 			t.Fatalf("ReadHeader(%s): %v", deltaID, err)
 		}
+
 		if gotSize != wantResolvedSize {
 			t.Fatalf("ReadHeader(%s) size = %d, want resolved size %d", deltaID, gotSize, wantResolvedSize)
 		}
+
 		gotReadSize, err := store.ReadSize(deltaID)
 		if err != nil {
 			t.Fatalf("ReadSize(%s): %v", deltaID, err)
 		}
+
 		if gotReadSize != wantResolvedSize {
 			t.Fatalf("ReadSize(%s) = %d, want resolved size %d", deltaID, gotReadSize, wantResolvedSize)
 		}
@@ -209,6 +254,7 @@ func findDeltaObjectWithResolvedSizeMismatch(t *testing.T, testRepo *testgit.Tes
 	if err != nil {
 		t.Fatalf("Glob idx: %v", err)
 	}
+
 	if len(idxFiles) == 0 {
 		t.Fatalf("no idx files found")
 	}
@@ -221,16 +267,19 @@ func findDeltaObjectWithResolvedSizeMismatch(t *testing.T, testRepo *testgit.Tes
 		}
 
 		idHex := fields[0]
+
 		deltaStreamSize, err := strconv.ParseInt(fields[2], 10, 64)
 		if err != nil {
 			continue
 		}
 
 		resolvedSizeStr := testRepo.Run(t, "cat-file", "-s", idHex)
+
 		resolvedSize, err := strconv.ParseInt(strings.TrimSpace(resolvedSizeStr), 10, 64)
 		if err != nil {
 			t.Fatalf("parse cat-file size for %s: %v", idHex, err)
 		}
+
 		if deltaStreamSize == resolvedSize {
 			continue
 		}
@@ -239,9 +288,11 @@ func findDeltaObjectWithResolvedSizeMismatch(t *testing.T, testRepo *testgit.Tes
 		if err != nil {
 			t.Fatalf("ParseHex(%s): %v", idHex, err)
 		}
+
 		return id, resolvedSize
 	}
 
 	t.Fatalf("did not find a delta object with mismatched stream/resolved size")
+
 	return objectid.ObjectID{}, 0
 }