Files
wuffs/lib/suitar/suitar_test.go
T
rootkiller6788 193d0354b4 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.
2026-09-12 23:48:25 +08:00

349 lines
9.0 KiB
Go

// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
package suitar
import (
"archive/tar"
"bytes"
"errors"
"fmt"
"hash/crc32"
"io"
"os"
"testing"
"time"
)
type crcWriter uint32
func (c *crcWriter) Write(b []byte) (int, error) {
state := uint32(*c)
state = crc32.Update(state, crc32.IEEETable, b)
*c = crcWriter(state)
return len(b), nil
}
func testWriter(tt *testing.T, sparse bool) {
f, err := os.Open("../../test/data/archive.tar")
if err != nil {
tt.Fatalf("os.Open: %v", err)
}
defer f.Close()
// Convert from t (tar, using the standard library) to s (suitar, using
// this package).
buf := bytes.Buffer{}
sWriter := NewWriter(&buf)
for tReader := tar.NewReader(f); ; {
tHeader, err := tReader.Next()
if err == io.EOF {
break
} else if err != nil {
tt.Fatalf("Next: %v", err)
}
sHeader := &Header{
Typeflag: tHeader.Typeflag,
Name: tHeader.Name,
Size: tHeader.Size,
Mode: tHeader.Mode,
ModTime: tHeader.ModTime,
}
if sparse && (sHeader.Typeflag == TypeReg) {
sHeader.Typeflag = TypeGNUSparse
}
if err := sWriter.WriteHeader(sHeader); err != nil {
tt.Fatalf("WriteHeader: %v", err)
}
dstWriter := (io.Writer)(sWriter)
if sparse {
dstWriter = io.Discard
}
if _, err := io.Copy(dstWriter, tReader); err != nil {
tt.Fatalf("io.Copy: %v", err)
}
}
if err := sWriter.Close(); err != nil {
tt.Fatalf("Close: %v", err)
}
got := buf.Bytes()
wantFilename := "../../test/data/archive"
if sparse {
wantFilename += ".sparse.suitar"
} else {
wantFilename += ".dense.suitar"
}
want, err := os.ReadFile(wantFilename)
if err != nil {
tt.Fatalf("os.ReadFile: %v", err)
}
if !bytes.Equal(got, want) {
tt.Fatalf("did not recreate golden test file")
}
}
func testReader(tt *testing.T, sparse bool, ignore bool) {
filename, wantTypeflag := "../../test/data/archive.dense.suitar", " T:'0'"
if sparse {
filename, wantTypeflag = "../../test/data/archive.sparse.suitar", " T:'S'"
}
wantChecksums := []string(nil)
if ignore {
wantChecksums = []string{
"C:0x00000000",
"C:0x00000000",
"C:0x00000000",
"C:0x00000000",
"C:0x00000000",
"C:0x00000000",
"C:0x00000000",
"C:0x00000000",
}
} else if sparse {
wantChecksums = []string{
"C:0x00000000",
"C:0xB69F8E37",
"C:0x73FF3CAE",
"C:0xD71F022F",
"C:0xC446EAB8",
"C:0x5F228EB9",
"C:0x7BA7D011",
"C:0x48792A7F",
}
} else {
wantChecksums = []string{
"C:0x00000000",
"C:0xFEDD8F35",
"C:0x87EE5E05",
"C:0x703E9270",
"C:0xC37CB538",
"C:0x2B0B23B0",
"C:0xABE507EF",
"C:0x67FABE9C",
}
}
want := "" +
wantChecksums[0] + wantTypeflag + " S:0x0000 M:644 MT:0x5E3A5C50 N:artificial/0.bytes\n" +
wantChecksums[1] + wantTypeflag + " S:0x0355 M:644 MT:0x5F33F6E6 N:github-tags.json\n" +
wantChecksums[2] + wantTypeflag + " S:0x02B5 M:755 MT:0x608F960B N:hello.sh\n" +
wantChecksums[3] + wantTypeflag + " S:0x0068 M:644 MT:0x608F954D N:non-ascii/αβ.txt\n" +
wantChecksums[4] + wantTypeflag + " S:0x0097 M:644 MT:0x608F96C7 N:non-ascii/😻.txt\n" +
wantChecksums[5] + wantTypeflag + " S:0x00D0 M:644 MT:0x5E3A5C50 N:pjw-thumbnail.png\n" +
wantChecksums[6] + wantTypeflag + " S:0x03AE M:644 MT:0x5E3A5C50 N:romeo.txt\n" +
wantChecksums[7] + wantTypeflag + " S:0x022E M:644 MT:0x5E3A5C50 N:romeo.txt.gz\n" +
""
f, err := os.Open(filename)
if err != nil {
tt.Fatalf("os.Open: %v", err)
}
defer f.Close()
buf := bytes.Buffer{}
for r := NewReader(f); ; {
h, err := r.Next()
if err == io.EOF {
break
} else if err != nil {
tt.Fatalf("Next: %v", err)
}
checksum := crcWriter(0)
if !ignore {
if _, err := io.Copy(&checksum, r); err != nil {
tt.Fatalf("io.Copy: %v", err)
}
}
fmt.Fprintf(&buf, "C:0x%08X T:'%c' S:0x%04X M:%3o MT:0x%08X N:%s\n",
checksum, h.Typeflag, h.Size, h.Mode, h.ModTime.Unix(), h.Name)
}
if got := buf.String(); got != want {
tt.Fatalf("\ngot:\n%s\nwant:\n%s", got, want)
}
}
func TestWriterDense(tt *testing.T) { testWriter(tt, false) }
func TestWriterSparse(tt *testing.T) { testWriter(tt, true) }
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)
}
}