From c0e3ca8389d3692f24b35b5f8bc4022ae712d141 Mon Sep 17 00:00:00 2001
From: Runxi Yu
Date: Thu, 5 Mar 2026 21:33:12 +0800
Subject: *: I guess os.Root is alright for tests too *shrug*

---
 format/pack/ingest/ingest_test.go     | 50 ++++++++++++++++++++++++++++++-----
 internal/compress/zlib/writer_test.go | 31 +++++++++++++---------
 2 files changed, 63 insertions(+), 18 deletions(-)

diff --git a/format/pack/ingest/ingest_test.go b/format/pack/ingest/ingest_test.go
index 0e51e0fd..d3bb9e41 100644
--- a/format/pack/ingest/ingest_test.go
+++ b/format/pack/ingest/ingest_test.go
@@ -42,10 +42,24 @@ func fixtureBytes(t *testing.T, algo objectid.Algorithm, name string) []byte {
 	t.Helper()
 
 	path := fixturePath(t, algo, name)
+	dir := filepath.Dir(path)
+	base := filepath.Base(path)
 
-	data, err := os.ReadFile(path)
+	root, err := os.OpenRoot(dir)
 	if err != nil {
-		t.Fatalf("read fixture %q: %v", path, err)
+		t.Fatalf("open fixture root %q: %v", dir, err)
+	}
+
+	defer func() {
+		err := root.Close()
+		if err != nil {
+			t.Fatalf("close fixture root %q: %v", dir, err)
+		}
+	}()
+
+	data, err := root.ReadFile(base)
+	if err != nil {
+		t.Fatalf("read fixture %q: %v", base, err)
 	}
 
 	return data
@@ -104,12 +118,36 @@ func verifyReindexOracle(t *testing.T, repo *testgit.TestRepo, packPath, idxPath
 	_ = repo.Run(t, "index-pack", "--rev-index", "-o", oracleIdxPath, packPath)
 	oracleRevPath := strings.TrimSuffix(oracleIdxPath, ".idx") + ".rev"
 
-	gotIdx, err := os.ReadFile(idxPath)
+	idxRoot, err := os.OpenRoot(filepath.Dir(idxPath))
+	if err != nil {
+		t.Fatalf("open idx root: %v", err)
+	}
+
+	defer func() {
+		err := idxRoot.Close()
+		if err != nil {
+			t.Fatalf("close idx root: %v", err)
+		}
+	}()
+
+	gotIdx, err := idxRoot.ReadFile(filepath.Base(idxPath))
 	if err != nil {
 		t.Fatalf("read idx: %v", err)
 	}
 
-	wantIdx, err := os.ReadFile(oracleIdxPath)
+	oracleRoot, err := os.OpenRoot(oracleDir)
+	if err != nil {
+		t.Fatalf("open oracle root: %v", err)
+	}
+
+	defer func() {
+		err := oracleRoot.Close()
+		if err != nil {
+			t.Fatalf("close oracle root: %v", err)
+		}
+	}()
+
+	wantIdx, err := oracleRoot.ReadFile(filepath.Base(oracleIdxPath))
 	if err != nil {
 		t.Fatalf("read oracle idx: %v", err)
 	}
@@ -118,12 +156,12 @@ func verifyReindexOracle(t *testing.T, repo *testgit.TestRepo, packPath, idxPath
 		t.Fatal("idx bytes differ from git index-pack output")
 	}
 
-	gotRev, err := os.ReadFile(revPath)
+	gotRev, err := idxRoot.ReadFile(filepath.Base(revPath))
 	if err != nil {
 		t.Fatalf("read rev: %v", err)
 	}
 
-	wantRev, err := os.ReadFile(oracleRevPath)
+	wantRev, err := oracleRoot.ReadFile(filepath.Base(oracleRevPath))
 	if err != nil {
 		t.Fatalf("read oracle rev: %v", err)
 	}
diff --git a/internal/compress/zlib/writer_test.go b/internal/compress/zlib/writer_test.go
index f3bfb437..e67a3539 100644
--- a/internal/compress/zlib/writer_test.go
+++ b/internal/compress/zlib/writer_test.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"testing"
 
 	"codeberg.org/lindenii/furgit/internal/compress/zlib"
@@ -24,29 +25,35 @@ var data = []string{
 	"test a reasonable sized string that can be compressed",
 }
 
+func testdataRoot(t *testing.T) *os.Root {
+	t.Helper()
+
+	root, err := os.OpenRoot("../testdata")
+	if err != nil {
+		t.Fatalf("open testdata root: %v", err)
+	}
+
+	return root
+}
+
 // Tests that compressing and then decompressing the given file at the given compression level and dictionary
 // yields equivalent bytes to the original file.
 func testFileLevelDict(t *testing.T, fn string, level int, d string) {
 	t.Helper()
 
-	// Read the file, as golden output.
-	golden, err := os.Open(fn)
-	if err != nil {
-		t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err)
-
-		return
-	}
+	root := testdataRoot(t)
 
 	defer func() {
-		err := golden.Close()
+		err := root.Close()
 		if err != nil {
-			t.Fatalf("%s (level=%d, dict=%q): close golden: %v", fn, level, d, err)
+			t.Fatalf("%s (level=%d, dict=%q): close testdata root: %v", fn, level, d, err)
 		}
 	}()
 
-	b0, err0 := io.ReadAll(golden)
-	if err0 != nil {
-		t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err0)
+	// Read the file, as golden output.
+	b0, err := root.ReadFile(filepath.Base(fn))
+	if err != nil {
+		t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err)
 
 		return
 	}
-- 
cgit v1.3.1-10-gc9f91