chore: revert minor changes

Author: ldez

internal/cache/cache.go

@@ -50,13 +50,14 @@ type Cache struct {
 // to share a cache directory (for example, if the directory were stored
 // in a network file system). File locking is notoriously unreliable in
 // network file systems and may not suffice to protect the cache.
+//
 func Open(dir string) (*Cache, error) {
 	info, err := os.Stat(dir)
 	if err != nil {
 		return nil, err
 	}
 	if !info.IsDir() {
-		return nil, &os.PathError{Op: "open", Path: dir, Err: errors.New("not a directory")}
+		return nil, &os.PathError{Op: "open", Path: dir, Err: fmt.Errorf("not a directory")}
 	}
 	for i := 0; i < 256; i++ {
 		name := filepath.Join(dir, fmt.Sprintf("%02x", i))
@@ -165,7 +166,7 @@ func (c *Cache) get(id ActionID) (Entry, error) {
 	eid, entry := entry[3:3+hexSize], entry[3+hexSize:]
 	eout, entry := entry[1:1+hexSize], entry[1+hexSize:]
 	esize, entry := entry[1:1+20], entry[1+20:]
-	etime := entry[1 : 1+20]
+	etime, entry := entry[1:1+20], entry[1+20:]
 	var buf [HashSize]byte
 	if _, err = hex.Decode(buf[:], eid); err != nil || buf != id {
 		return failed(fmt.Errorf("failed to hex decode eid data in %s: %w", fileName, err))
@@ -255,7 +256,7 @@ const (
 // and to reduce the amount of disk activity caused by using
 // cache entries, used only updates the mtime if the current
 // mtime is more than an hour old. This heuristic eliminates
-// nearly all the mtime updates that would otherwise happen,
+// nearly all of the mtime updates that would otherwise happen,
 // while still keeping the mtimes useful for cache trimming.
 func (c *Cache) used(file string) error {
 	info, err := os.Stat(file)
@@ -301,15 +302,15 @@ func (c *Cache) Trim() {
 
 	// Ignore errors from here: if we don't write the complete timestamp, the
 	// cache will appear older than it is, and we'll trim it again next time.
-	_ = renameio.WriteFile(filepath.Join(c.dir, "trim.txt"), []byte(fmt.Sprintf("%d", now.Unix())), 0666)
+	renameio.WriteFile(filepath.Join(c.dir, "trim.txt"), []byte(fmt.Sprintf("%d", now.Unix())), 0666)
 }
 
 // trimSubdir trims a single cache subdirectory.
 func (c *Cache) trimSubdir(subdir string, cutoff time.Time) {
 	// Read all directory entries from subdir before removing
 	// any files, in case removing files invalidates the file offset
 	// in the directory scan. Also, ignore error from f.Readdirnames,
-	// because we don't care about reporting the error, and we still
+	// because we don't care about reporting the error and we still
 	// want to process any entries found before the error.
 	f, err := os.Open(subdir)
 	if err != nil {
@@ -346,7 +347,6 @@ func (c *Cache) putIndexEntry(id ActionID, out OutputID, size int64, allowVerify
 	// are entirely reproducible. As just noted, this may be unrealistic
 	// in some cases but the check is also useful for shaking out real bugs.
 	entry := fmt.Sprintf("v1 %x %x %20d %20d\n", id, out, size, time.Now().UnixNano())
-
 	if verify && allowVerify {
 		old, err := c.get(id)
 		if err == nil && (old.OutputID != out || old.Size != size) {
@@ -368,7 +368,7 @@ func (c *Cache) putIndexEntry(id ActionID, out OutputID, size int64, allowVerify
 		// Truncate the file only *after* writing it.
 		// (This should be a no-op, but truncate just in case of previous corruption.)
 		//
-		// This differs from os.WriteFile, which truncates to 0 *before* writing
+		// This differs from ioutil.WriteFile, which truncates to 0 *before* writing
 		// via os.O_TRUNC. Truncating only after writing ensures that a second write
 		// of the same content to the same file is idempotent, and does not — even
 		// temporarily! — undo the effect of the first write.
@@ -502,7 +502,7 @@ func (c *Cache) copyFile(file io.ReadSeeker, out OutputID, size int64) error {
 	sum := h.Sum(nil)
 	if !bytes.Equal(sum, out[:]) {
 		_ = f.Truncate(0)
-		return errors.New("file content changed underfoot")
+		return fmt.Errorf("file content changed underfoot")
 	}
 
 	// Commit cache file entry.

internal/cache/cache_test.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
@@ -19,9 +20,7 @@ func init() {
 }
 
 func TestBasic(t *testing.T) {
-	t.Parallel()
-
-	dir, err := os.MkdirTemp("", "cachetest-")
+	dir, err := ioutil.TempDir("", "cachetest-")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -66,9 +65,7 @@ func TestBasic(t *testing.T) {
 }
 
 func TestGrowth(t *testing.T) {
-	t.Parallel()
-
-	dir, err := os.MkdirTemp("", "cachetest-")
+	dir, err := ioutil.TempDir("", "cachetest-")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -81,7 +78,7 @@ func TestGrowth(t *testing.T) {
 
 	n := 10000
 	if testing.Short() {
-		n = 1000
+		n = 10
 	}
 
 	for i := 0; i < n; i++ {
@@ -121,7 +118,7 @@ func TestVerifyPanic(t *testing.T) {
 		t.Fatal("initEnv did not set verify")
 	}
 
-	dir, err := os.MkdirTemp("", "cachetest-")
+	dir, err := ioutil.TempDir("", "cachetest-")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -154,9 +151,7 @@ func dummyID(x int) [HashSize]byte {
 }
 
 func TestCacheTrim(t *testing.T) {
-	t.Parallel()
-
-	dir, err := os.MkdirTemp("", "cachetest-")
+	dir, err := ioutil.TempDir("", "cachetest-")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -212,7 +207,7 @@ func TestCacheTrim(t *testing.T) {
 		t.Fatal(err)
 	}
 	c.OutputFile(entry.OutputID)
-	data, err := os.ReadFile(filepath.Join(dir, "trim.txt"))
+	data, err := ioutil.ReadFile(filepath.Join(dir, "trim.txt"))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -225,15 +220,15 @@ func TestCacheTrim(t *testing.T) {
 		t.Fatal(err)
 	}
 	c.OutputFile(entry.OutputID)
-	data2, err := os.ReadFile(filepath.Join(dir, "trim.txt"))
+	data2, err := ioutil.ReadFile(filepath.Join(dir, "trim.txt"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !bytes.Equal(data, data2) {
 		t.Fatalf("second trim did work: %q -> %q", data, data2)
 	}
 
-	// Fast-forward and do another trim just before the 5-day cutoff.
+	// Fast forward and do another trim just before the 5 day cutoff.
 	// Note that because of usedQuantum the cutoff is actually 5 days + 1 hour.
 	// We used c.Get(id) just now, so 5 days later it should still be kept.
 	// On the other hand almost a full day has gone by since we wrote dummyID(2)

internal/cache/hash_test.go

@@ -6,6 +6,7 @@ package cache
 
 import (
 	"fmt"
+	"io/ioutil"
 	"os"
 	"testing"
 )
@@ -27,7 +28,7 @@ func TestHash(t *testing.T) {
 }
 
 func TestHashFile(t *testing.T) {
-	f, err := os.CreateTemp("", "cmd-go-test-")
+	f, err := ioutil.TempFile("", "cmd-go-test-")
 	if err != nil {
 		t.Fatal(err)
 	}