lib/suitar: test chunked writes and directory entries

TestWriterChunked writes one file several times, splitting the contents
over Write calls differently each time, and checks the archive bytes come
out identical. The capped writer makes a runaway Write fail the test
instead of hanging it.

TestWriterDir writes a directory and then a file inside it, and reads
both back.
This commit is contained in:
rootkiller6788 committed 2026-09-12 23:48:25 +08:00
1 parent 26ce8600a1
commit 193d0354b4
1 file changed
+162
+162
View File
@@ -13,11 +13,13 @@ package suitar
import (
"archive/tar"
"bytes"
"errors"
"fmt"
"hash/crc32"
"io"
"os"
"testing"
"time"
)
type crcWriter uint32
@@ -184,3 +186,163 @@ func TestReaderDenseCheck(tt *testing.T) { testReader(tt, false, false) }
func TestReaderDenseIgnore(tt *testing.T) { testReader(tt, false, true) }
func TestReaderSparseCheck(tt *testing.T) { testReader(tt, true, false) }
func TestReaderSparseIgnore(tt *testing.T) { testReader(tt, true, true) }
// cappedWriter returns an error once the total number of bytes written would
// exceed limit, so that a Writer which runs away fails this test instead of
// hanging it.
type cappedWriter struct {
buf bytes.Buffer
limit int
}
func (w *cappedWriter) Write(b []byte) (int, error) {
if w.buf.Len()+len(b) > w.limit {
return 0, errCappedWriter
}
return w.buf.Write(b)
}
var errCappedWriter = errors.New("suitar_test: capped writer")
// writeOneFile returns a SUITAR archive holding a single file whose contents
// are size bytes long, written in chunks of chunk bytes (or all at once if
// chunk is non-positive).
func writeOneFile(tt *testing.T, size int, chunk int) []byte {
tt.Helper()
cw := &cappedWriter{limit: 0x10000}
w := NewWriter(cw)
err := w.WriteHeader(&Header{
Typeflag: TypeReg,
Name: "file.bin",
Size: int64(size),
Mode: Mode644,
ModTime: time.Unix(0x5E3A5C50, 0),
})
if err != nil {
tt.Fatalf("size=%d chunk=%d: WriteHeader: %v", size, chunk, err)
}
pix := make([]byte, size)
for i := range pix {
pix[i] = byte(i)
}
if chunk <= 0 {
if _, err := w.Write(pix); err != nil {
tt.Fatalf("size=%d chunk=%d: Write: %v", size, chunk, err)
}
} else {
for i := 0; i < size; i += chunk {
j := min(i+chunk, size)
if _, err := w.Write(pix[i:j]); err != nil {
tt.Fatalf("size=%d chunk=%d: Write[%d:%d]: %v", size, chunk, i, j, err)
}
}
}
if err := w.Close(); err != nil {
tt.Fatalf("size=%d chunk=%d: Close: %v", size, chunk, err)
}
return cw.buf.Bytes()
}
// TestWriterChunked checks that how the file contents are split up over Write
// calls doesn't matter, as long as the total is Header.Size bytes long. A
// chunk size that isn't a multiple of 512 used to loop forever, writing
// 512-byte blocks non-stop, and also to duplicate one 512-byte block.
func TestWriterChunked(tt *testing.T) {
for _, size := range []int{0, 1, 300, 511, 512, 513, 700, 1000, 1024, 5000} {
want := writeOneFile(tt, size, 0)
for _, chunk := range []int{1, 100, 300, 511, 512, 700, 1024} {
if got := writeOneFile(tt, size, chunk); !bytes.Equal(got, want) {
tt.Fatalf("size=%d chunk=%d: chunk size changed the archive bytes", size, chunk)
}
}
r := NewReader(bytes.NewReader(want))
h, err := r.Next()
if err != nil {
tt.Fatalf("size=%d: Next: %v", size, err)
} else if (h.Typeflag != TypeReg) || (h.Size != int64(size)) {
tt.Fatalf("size=%d: got T:'%c' S:%d", size, h.Typeflag, h.Size)
}
got, err := io.ReadAll(r)
if err != nil {
tt.Fatalf("size=%d: ReadAll: %v", size, err)
} else if len(got) != size {
tt.Fatalf("size=%d: read back %d bytes", size, len(got))
} else {
for i, c := range got {
if c != byte(i) {
tt.Fatalf("size=%d: contents differ at %d", size, i)
break
}
}
}
if _, err := r.Next(); err != io.EOF {
tt.Fatalf("size=%d: Next after the last entry: %v", size, err)
}
}
}
// TestWriterDir checks that a directory entry, which has no contents, can be
// written and read back.
func TestWriterDir(tt *testing.T) {
buf := bytes.Buffer{}
w := NewWriter(&buf)
for _, h := range []*Header{
{
Typeflag: TypeDir,
Name: "a/b",
Mode: Mode755,
ModTime: time.Unix(0x5E3A5C50, 0),
},
{
Typeflag: TypeReg,
Name: "a/b/c.txt",
Size: 5,
Mode: Mode644,
ModTime: time.Unix(0x5E3A5C50, 0),
},
} {
if err := w.WriteHeader(h); err != nil {
tt.Fatalf("WriteHeader(%q): %v", h.Name, err)
}
if h.Typeflag == TypeReg {
if _, err := w.Write([]byte("hello")); err != nil {
tt.Fatalf("Write: %v", err)
}
}
}
if err := w.Close(); err != nil {
tt.Fatalf("Close: %v", err)
}
r := NewReader(bytes.NewReader(buf.Bytes()))
for _, want := range []struct {
typeflag byte
name string
contents string
}{
{TypeDir, "a/b", ""},
{TypeReg, "a/b/c.txt", "hello"},
} {
h, err := r.Next()
if err != nil {
tt.Fatalf("Next: %v", err)
} else if (h.Typeflag != want.typeflag) || (h.Name != want.name) {
tt.Fatalf("got T:'%c' N:%s, want T:'%c' N:%s",
h.Typeflag, h.Name, want.typeflag, want.name)
}
if got, err := io.ReadAll(r); err != nil {
tt.Fatalf("ReadAll: %v", err)
} else if string(got) != want.contents {
tt.Fatalf("N:%s: got %q, want %q", want.name, got, want.contents)
}
}
if _, err := r.Next(); err != io.EOF {
tt.Fatalf("Next after the last entry: %v", err)
}
}