import (
"bytes"
+ "crypto/sha256"
"fmt"
"internal/race"
"internal/testenv"
"io"
"os"
"os/exec"
+ "path/filepath"
"strings"
"sync"
"testing"
"",
"\x28\xb5\x2f\xfd\x00\x00\x15\x00\x00\x00\x00",
},
+ {
+ "single skippable frame",
+ "",
+ "\x50\x2a\x4d\x18\x00\x00\x00\x00",
+ },
+ {
+ "two skippable frames",
+ "",
+ "\x50\x2a\x4d\x18\x00\x00\x00\x00" +
+ "\x50\x2a\x4d\x18\x00\x00\x00\x00",
+ },
}
func TestSamples(t *testing.T) {
}
}
+func TestReset(t *testing.T) {
+ input := strings.NewReader("")
+ r := NewReader(input)
+ for _, test := range tests {
+ test := test
+ t.Run(test.name, func(t *testing.T) {
+ input.Reset(test.compressed)
+ r.Reset(input)
+ got, err := io.ReadAll(r)
+ if err != nil {
+ t.Fatal(err)
+ }
+ gotstr := string(got)
+ if gotstr != test.uncompressed {
+ t.Errorf("got %q want %q", gotstr, test.uncompressed)
+ }
+ })
+ }
+}
+
var (
bigDataOnce sync.Once
bigDataBytes []byte
return bigDataBytes
}
+func findZstd(t testing.TB) string {
+ zstd, err := exec.LookPath("zstd")
+ if err != nil {
+ t.Skip("skipping because zstd not found")
+ }
+ return zstd
+}
+
var (
zstdBigOnce sync.Once
zstdBigBytes []byte
- zstdBigSkip bool
zstdBigErr error
)
func zstdBigData(t testing.TB) []byte {
input := bigData(t)
- zstdBigOnce.Do(func() {
- if _, err := os.Stat("/usr/bin/zstd"); err != nil {
- zstdBigSkip = true
- return
- }
+ zstd := findZstd(t)
- cmd := exec.Command("/usr/bin/zstd", "-z")
+ zstdBigOnce.Do(func() {
+ cmd := exec.Command(zstd, "-z")
cmd.Stdin = bytes.NewReader(input)
var compressed bytes.Buffer
cmd.Stdout = &compressed
zstdBigBytes = compressed.Bytes()
})
- if zstdBigSkip {
- t.Skip("skipping because /usr/bin/zstd does not exist")
- }
if zstdBigErr != nil {
t.Fatal(zstdBigErr)
}
data := bigData(t)
compressed := zstdBigData(t)
- t.Logf("/usr/bin/zstd compressed %d bytes to %d", len(data), len(compressed))
+ t.Logf("zstd compressed %d bytes to %d", len(data), len(compressed))
r := NewReader(bytes.NewReader(compressed))
got, err := io.ReadAll(r)
}
}
+func TestFileSamples(t *testing.T) {
+ samples, err := os.ReadDir("testdata")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for _, sample := range samples {
+ name := sample.Name()
+ if !strings.HasSuffix(name, ".zst") {
+ continue
+ }
+
+ t.Run(name, func(t *testing.T) {
+ f, err := os.Open(filepath.Join("testdata", name))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ r := NewReader(f)
+ h := sha256.New()
+ if _, err := io.Copy(h, r); err != nil {
+ t.Fatal(err)
+ }
+ got := fmt.Sprintf("%x", h.Sum(nil))[:8]
+
+ want, _, _ := strings.Cut(name, ".")
+ if got != want {
+ t.Errorf("Wrong uncompressed content hash: got %s, want %s", got, want)
+ }
+ })
+ }
+}
+
func BenchmarkLarge(b *testing.B) {
b.StopTimer()
b.ReportAllocs()