1082 lines
30 KiB
Go
1082 lines
30 KiB
Go
|
//go:build linux || freebsd
|
||
|
|
// +build linux freebsd
|
||
|
|
|
||
|
|
package compression
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bytes"
|
||
|
|
"compress/flate"
|
||
|
|
"compress/lzw"
|
||
|
|
"io"
|
||
|
|
"strings"
|
||
|
|
"testing"
|
||
|
|
)
|
||
|
|
|
||
|
|
// testData is the sample data used for compression/decompression round-trip tests.
|
||
|
|
var testData = []byte("Hello, World! This is a test of the compression package. " +
|
||
|
|
"It contains various compression algorithms including gzip, flate, zlib, lzw, and bzip2. " +
|
||
|
|
"The quick brown fox jumps over the lazy dog. 1234567890!@#$%^&*()")
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// BaseDecompressor Tests
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestBaseDecompressor(t *testing.T) {
|
||
|
|
t.Run("Name", func(t *testing.T) {
|
||
|
|
bd := NewBaseDecompressor("test-name", []string{"gzip"}, []string{".gz"})
|
||
|
|
if got := bd.Name(); got != "test-name" {
|
||
|
|
t.Errorf("Name() = %q, want %q", got, "test-name")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Extensions", func(t *testing.T) {
|
||
|
|
want := []string{".gz", ".tgz"}
|
||
|
|
bd := NewBaseDecompressor("test", []string{"gzip"}, want)
|
||
|
|
got := bd.Extensions()
|
||
|
|
if len(got) != len(want) {
|
||
|
|
t.Fatalf("Extensions() length = %d, want %d", len(got), len(want))
|
||
|
|
}
|
||
|
|
for i := range want {
|
||
|
|
if got[i] != want[i] {
|
||
|
|
t.Errorf("Extensions()[%d] = %q, want %q", i, got[i], want[i])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandle", func(t *testing.T) {
|
||
|
|
bd := NewBaseDecompressor("test", []string{"gzip", "x-gzip"}, []string{".gz"})
|
||
|
|
cases := []struct {
|
||
|
|
encoding string
|
||
|
|
want bool
|
||
|
|
}{
|
||
|
|
{"gzip", true},
|
||
|
|
{"GZIP", true},
|
||
|
|
{"Gzip", true},
|
||
|
|
{"x-gzip", true},
|
||
|
|
{"X-GZIP", true},
|
||
|
|
{"x-Gzip", true},
|
||
|
|
{"deflate", false},
|
||
|
|
{"bzip2", false},
|
||
|
|
{"identity", false},
|
||
|
|
{"", false},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
if got := bd.CanHandle(tc.encoding); got != tc.want {
|
||
|
|
t.Errorf("CanHandle(%q) = %v, want %v", tc.encoding, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandle with empty encodings list", func(t *testing.T) {
|
||
|
|
bd := NewBaseDecompressor("empty", []string{}, []string{".ext"})
|
||
|
|
if bd.CanHandle("anything") {
|
||
|
|
t.Error("CanHandle('anything') = true, want false for empty encodings list")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile", func(t *testing.T) {
|
||
|
|
bd := NewBaseDecompressor("test", []string{"gzip"}, []string{".gz", ".tgz"})
|
||
|
|
cases := []struct {
|
||
|
|
filename string
|
||
|
|
want bool
|
||
|
|
}{
|
||
|
|
{"file.gz", true},
|
||
|
|
{"file.GZ", true},
|
||
|
|
{"file.Gz", true},
|
||
|
|
{"archive.tar.gz", true},
|
||
|
|
{"archive.tar.tgz", true},
|
||
|
|
{".gz", true},
|
||
|
|
{"file.bz2", false},
|
||
|
|
{"file.txt", false},
|
||
|
|
{"file", false},
|
||
|
|
{"", false},
|
||
|
|
{"filegz", false}, // not a suffix
|
||
|
|
{"file.gzip", false}, // .gzip not in list
|
||
|
|
{".tgz", true},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
if got := bd.CanHandleFile(tc.filename); got != tc.want {
|
||
|
|
t.Errorf("CanHandleFile(%q) = %v, want %v", tc.filename, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile with empty extensions list", func(t *testing.T) {
|
||
|
|
bd := NewBaseDecompressor("empty", []string{"gzip"}, []string{})
|
||
|
|
if bd.CanHandleFile("anything.gz") {
|
||
|
|
t.Error("CanHandleFile('anything.gz') = true, want false for empty extensions list")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Registry Tests
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
// testDecompressor is a minimal Decompressor implementation for registry testing.
|
||
|
|
// It embeds a BaseDecompressor so CanHandle/CanHandleFile can delegate to it.
|
||
|
|
type testDecompressor struct {
|
||
|
|
*BaseDecompressor
|
||
|
|
name string
|
||
|
|
}
|
||
|
|
|
||
|
|
func (td *testDecompressor) Name() string { return td.name }
|
||
|
|
func (td *testDecompressor) Reader(r io.Reader) (io.ReadCloser, error) {
|
||
|
|
return io.NopCloser(r), nil
|
||
|
|
}
|
||
|
|
func (td *testDecompressor) CanHandle(contentEncoding string) bool {
|
||
|
|
if td.BaseDecompressor != nil {
|
||
|
|
return td.BaseDecompressor.CanHandle(contentEncoding)
|
||
|
|
}
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
func (td *testDecompressor) CanHandleFile(filename string) bool {
|
||
|
|
if td.BaseDecompressor != nil {
|
||
|
|
return td.BaseDecompressor.CanHandleFile(filename)
|
||
|
|
}
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRegistry(t *testing.T) {
|
||
|
|
// Save and restore the global registry to isolate this test.
|
||
|
|
savedItems := globalRegistry.items
|
||
|
|
globalRegistry.items = make(map[string]Decompressor)
|
||
|
|
defer func() { globalRegistry.items = savedItems }()
|
||
|
|
|
||
|
|
t.Run("Register and Get", func(t *testing.T) {
|
||
|
|
d := &testDecompressor{name: "mytest"}
|
||
|
|
Register(d)
|
||
|
|
|
||
|
|
got, ok := Get("mytest")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('mytest') returned ok=false, want true")
|
||
|
|
}
|
||
|
|
if got.Name() != "mytest" {
|
||
|
|
t.Errorf("Get().Name() = %q, want %q", got.Name(), "mytest")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Get is case-insensitive", func(t *testing.T) {
|
||
|
|
d := &testDecompressor{name: "case-test"}
|
||
|
|
Register(d)
|
||
|
|
|
||
|
|
for _, name := range []string{"case-test", "CASE-TEST", "Case-Test"} {
|
||
|
|
got, ok := Get(name)
|
||
|
|
if !ok {
|
||
|
|
t.Errorf("Get(%q) returned ok=false, want true", name)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if got.Name() != "case-test" {
|
||
|
|
t.Errorf("Get(%q).Name() = %q, want %q", name, got.Name(), "case-test")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Get non-existent", func(t *testing.T) {
|
||
|
|
_, ok := Get("does-not-exist")
|
||
|
|
if ok {
|
||
|
|
t.Error("Get('does-not-exist') returned ok=true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Get empty string", func(t *testing.T) {
|
||
|
|
_, ok := Get("")
|
||
|
|
if ok {
|
||
|
|
t.Error("Get('') returned ok=true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Register overwrites existing", func(t *testing.T) {
|
||
|
|
d1 := &testDecompressor{name: "overwrite-me"}
|
||
|
|
d2 := &testDecompressor{name: "overwrite-me"}
|
||
|
|
Register(d1)
|
||
|
|
Register(d2)
|
||
|
|
|
||
|
|
got, ok := Get("overwrite-me")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('overwrite-me') returned ok=false, want true")
|
||
|
|
}
|
||
|
|
// d2 should have overwritten d1
|
||
|
|
if got != d2 {
|
||
|
|
t.Error("Register did not overwrite the existing entry")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("GetByFilename", func(t *testing.T) {
|
||
|
|
// Register a decompressor that maps to a known filename detection result.
|
||
|
|
fd := NewBaseDecompressor("gzip", []string{"gzip"}, []string{".gz"})
|
||
|
|
Register(&testDecompressor{BaseDecompressor: fd, name: "gzip"})
|
||
|
|
|
||
|
|
d, ok := GetByFilename("archive.tar.gz")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("GetByFilename('archive.tar.gz') returned ok=false, want true")
|
||
|
|
}
|
||
|
|
if d.Name() != "gzip" {
|
||
|
|
t.Errorf("GetByFilename().Name() = %q, want %q", d.Name(), "gzip")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("GetByFilename with identity (no match)", func(t *testing.T) {
|
||
|
|
_, ok := GetByFilename("plain.txt")
|
||
|
|
if ok {
|
||
|
|
t.Error("GetByFilename('plain.txt') returned ok=true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("GetByFilename with empty string", func(t *testing.T) {
|
||
|
|
_, ok := GetByFilename("")
|
||
|
|
if ok {
|
||
|
|
t.Error("GetByFilename('') returned ok=true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("GetByFilename with unknown format", func(t *testing.T) {
|
||
|
|
_, ok := GetByFilename("file.unknown")
|
||
|
|
if ok {
|
||
|
|
t.Error("GetByFilename('file.unknown') returned ok=true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Filename Detection Tests
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestDetectCompressionByFilename(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
filename string
|
||
|
|
want string
|
||
|
|
}{
|
||
|
|
// Gzip
|
||
|
|
{"file.gz", "gzip"},
|
||
|
|
{"archive.tar.gz", "gzip"},
|
||
|
|
{"file.GZ", "gzip"},
|
||
|
|
{"file.Gz", "gzip"},
|
||
|
|
{".gz", "gzip"},
|
||
|
|
{"/path/to/file.gz", "gzip"},
|
||
|
|
// Zlib
|
||
|
|
{"file.zlib", "zlib"},
|
||
|
|
{"file.Zlib", "zlib"},
|
||
|
|
{"file.ZLIB", "zlib"},
|
||
|
|
{"file.zz", "zlib"},
|
||
|
|
{"file.ZZ", "zlib"},
|
||
|
|
{".zlib", "zlib"},
|
||
|
|
{".zz", "zlib"},
|
||
|
|
// Flate / Deflate
|
||
|
|
{"file.deflate", "flate"},
|
||
|
|
{"file.DEFLATE", "flate"},
|
||
|
|
{"file.Deflate", "flate"},
|
||
|
|
{"file.fl", "flate"},
|
||
|
|
{"file.FL", "flate"},
|
||
|
|
{".deflate", "flate"},
|
||
|
|
{".fl", "flate"},
|
||
|
|
// Bzip2
|
||
|
|
{"file.bz2", "bzip2"},
|
||
|
|
{"file.BZ2", "bzip2"},
|
||
|
|
{"file.Bz2", "bzip2"},
|
||
|
|
{"file.tbz", "bzip2"},
|
||
|
|
{"file.TBZ", "bzip2"},
|
||
|
|
{"file.tbz2", "bzip2"},
|
||
|
|
{"file.TBZ2", "bzip2"},
|
||
|
|
{".bz2", "bzip2"},
|
||
|
|
{".tbz", "bzip2"},
|
||
|
|
{".tbz2", "bzip2"},
|
||
|
|
// LZW
|
||
|
|
{"file.Z", "lzw"},
|
||
|
|
{"file.lzw", "lzw"},
|
||
|
|
{"file.LZW", "lzw"},
|
||
|
|
{".Z", "lzw"},
|
||
|
|
{".lzw", "lzw"},
|
||
|
|
// Identity (no compression detected)
|
||
|
|
{"file.txt", "identity"},
|
||
|
|
{"file.tar", "identity"},
|
||
|
|
{"file", "identity"},
|
||
|
|
{"", "identity"},
|
||
|
|
{".", "identity"},
|
||
|
|
// Edge cases - false positives
|
||
|
|
{"file.gzip", "identity"}, // .gzip is not a registered extension
|
||
|
|
{"file.gz.txt", "identity"}, // .gz is not at the end
|
||
|
|
{"file.bz2.backup", "identity"},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
if got := DetectCompressionByFilename(tc.filename); got != tc.want {
|
||
|
|
t.Errorf("DetectCompressionByFilename(%q) = %q, want %q", tc.filename, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Content-Encoding Parsing Tests
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestParseContentEncoding(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
header string
|
||
|
|
want []string
|
||
|
|
}{
|
||
|
|
{"gzip", []string{"gzip"}},
|
||
|
|
{"deflate", []string{"deflate"}},
|
||
|
|
{"compress", []string{"compress"}},
|
||
|
|
{"identity", []string{"identity"}},
|
||
|
|
{"gzip, deflate", []string{"gzip", "deflate"}},
|
||
|
|
{" gzip , deflate ", []string{"gzip", "deflate"}},
|
||
|
|
{"gzip,deflate,identity", []string{"gzip", "deflate", "identity"}},
|
||
|
|
{" gzip ", []string{"gzip"}},
|
||
|
|
{"", []string{"identity"}},
|
||
|
|
{" ", []string{"identity"}},
|
||
|
|
{",,,", []string{"identity"}},
|
||
|
|
{"gzip,,deflate", []string{"gzip", "deflate"}},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
got := ParseContentEncoding(tc.header)
|
||
|
|
if !stringSliceEqual(got, tc.want) {
|
||
|
|
t.Errorf("ParseContentEncoding(%q) = %v, want %v", tc.header, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetEffectiveEncoding(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
encodings []string
|
||
|
|
want string
|
||
|
|
}{
|
||
|
|
{[]string{"gzip"}, "gzip"},
|
||
|
|
{[]string{"deflate"}, "deflate"},
|
||
|
|
{[]string{"identity"}, "identity"},
|
||
|
|
{[]string{"gzip", "identity"}, "gzip"},
|
||
|
|
{[]string{"identity", "gzip"}, "gzip"},
|
||
|
|
{[]string{"identity", "identity"}, "identity"},
|
||
|
|
{[]string{"identity", "gzip", "deflate"}, "gzip"},
|
||
|
|
{[]string{}, "identity"},
|
||
|
|
{nil, "identity"},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
if got := GetEffectiveEncoding(tc.encodings); got != tc.want {
|
||
|
|
t.Errorf("GetEffectiveEncoding(%v) = %q, want %q", tc.encodings, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetCompressionFromHeader(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
header string
|
||
|
|
want string
|
||
|
|
}{
|
||
|
|
{"gzip", "gzip"},
|
||
|
|
{"deflate", "deflate"},
|
||
|
|
{"compress", "compress"},
|
||
|
|
{"identity", "identity"},
|
||
|
|
{"", "identity"},
|
||
|
|
{"gzip, identity", "gzip"},
|
||
|
|
{"identity, gzip", "gzip"},
|
||
|
|
{"identity, identity", "identity"},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
if got := GetCompressionFromHeader(tc.header); got != tc.want {
|
||
|
|
t.Errorf("GetCompressionFromHeader(%q) = %q, want %q", tc.header, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestIsCompressedFile(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
filename string
|
||
|
|
want bool
|
||
|
|
}{
|
||
|
|
// Compressed
|
||
|
|
{"file.gz", true},
|
||
|
|
{"file.bz2", true},
|
||
|
|
{"file.tbz", true},
|
||
|
|
{"file.tbz2", true},
|
||
|
|
{"file.zlib", true},
|
||
|
|
{"file.zz", true},
|
||
|
|
{"file.deflate", true},
|
||
|
|
{"file.fl", true},
|
||
|
|
{"file.Z", true},
|
||
|
|
{"file.lzw", true},
|
||
|
|
{".gz", true},
|
||
|
|
// Not compressed
|
||
|
|
{"file.txt", false},
|
||
|
|
{"file.tar", false},
|
||
|
|
{"file", false},
|
||
|
|
{"", false},
|
||
|
|
{".", false},
|
||
|
|
{"file.gzip", false},
|
||
|
|
}
|
||
|
|
for _, tc := range cases {
|
||
|
|
if got := IsCompressedFile(tc.filename); got != tc.want {
|
||
|
|
t.Errorf("IsCompressedFile(%q) = %v, want %v", tc.filename, got, tc.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Gzip Round-trip Test
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestGzipDecompressor(t *testing.T) {
|
||
|
|
t.Run("Name", func(t *testing.T) {
|
||
|
|
d := NewGzipDecompressor()
|
||
|
|
if got := d.Name(); got != "gzip" {
|
||
|
|
t.Errorf("Name() = %q, want %q", got, "gzip")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandle", func(t *testing.T) {
|
||
|
|
d := NewGzipDecompressor()
|
||
|
|
if !d.CanHandle("gzip") {
|
||
|
|
t.Error("CanHandle('gzip') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandle("deflate") {
|
||
|
|
t.Error("CanHandle('deflate') = true, want false")
|
||
|
|
}
|
||
|
|
if d.CanHandle("") {
|
||
|
|
t.Error("CanHandle('') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile", func(t *testing.T) {
|
||
|
|
d := NewGzipDecompressor()
|
||
|
|
if !d.CanHandleFile("file.gz") {
|
||
|
|
t.Error("CanHandleFile('file.gz') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.GZ") {
|
||
|
|
t.Error("CanHandleFile('file.GZ') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file.bz2") {
|
||
|
|
t.Error("CanHandleFile('file.bz2') = true, want false")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file") {
|
||
|
|
t.Error("CanHandleFile('file') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip compress/decompress", func(t *testing.T) {
|
||
|
|
var compressed bytes.Buffer
|
||
|
|
|
||
|
|
// Compress
|
||
|
|
c := NewGzipCompressor()
|
||
|
|
writer, err := c.Writer(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("GzipCompressor.Writer() error = %v", err)
|
||
|
|
}
|
||
|
|
n, err := writer.Write(testData)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Write() error = %v", err)
|
||
|
|
}
|
||
|
|
if n != len(testData) {
|
||
|
|
t.Errorf("Write() wrote %d bytes, want %d", n, len(testData))
|
||
|
|
}
|
||
|
|
if err := writer.Close(); err != nil {
|
||
|
|
t.Fatalf("Close() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify compression happened (sanity check)
|
||
|
|
if compressed.Len() == 0 {
|
||
|
|
t.Fatal("Compressed output is empty")
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decompress
|
||
|
|
d := NewGzipDecompressor()
|
||
|
|
reader, err := d.Reader(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("GzipDecompressor.Reader() error = %v", err)
|
||
|
|
}
|
||
|
|
decompressed, err := io.ReadAll(reader)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ReadAll() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
if !bytes.Equal(decompressed, testData) {
|
||
|
|
t.Fatalf("Decompressed data mismatch:\ngot: %q\nwant: %q",
|
||
|
|
string(decompressed), string(testData))
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Decompress with invalid data", func(t *testing.T) {
|
||
|
|
d := NewGzipDecompressor()
|
||
|
|
_, err := d.Reader(strings.NewReader("not gzip data"))
|
||
|
|
if err == nil {
|
||
|
|
t.Error("GzipDecompressor.Reader() with invalid data expected error, got nil")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Name", func(t *testing.T) {
|
||
|
|
c := NewGzipCompressor()
|
||
|
|
if got := c.Name(); got != "gzip" {
|
||
|
|
t.Errorf("Compressor Name() = %q, want %q", got, "gzip")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Init registers decompressor", func(t *testing.T) {
|
||
|
|
d, ok := Get("gzip")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('gzip') returned ok=false after init, want true")
|
||
|
|
}
|
||
|
|
if d.Name() != "gzip" {
|
||
|
|
t.Errorf("Get('gzip').Name() = %q, want %q", d.Name(), "gzip")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Flate Round-trip Test
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestFlateDecompressor(t *testing.T) {
|
||
|
|
t.Run("Name", func(t *testing.T) {
|
||
|
|
d := NewFlateDecompressor()
|
||
|
|
if got := d.Name(); got != "flate" {
|
||
|
|
t.Errorf("Name() = %q, want %q", got, "flate")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile", func(t *testing.T) {
|
||
|
|
d := NewFlateDecompressor()
|
||
|
|
if !d.CanHandleFile("file.deflate") {
|
||
|
|
t.Error("CanHandleFile('file.deflate') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.fl") {
|
||
|
|
t.Error("CanHandleFile('file.fl') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.DEFLATE") {
|
||
|
|
t.Error("CanHandleFile('file.DEFLATE') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file.gz") {
|
||
|
|
t.Error("CanHandleFile('file.gz') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip compress/decompress default level", func(t *testing.T) {
|
||
|
|
compressAndDecompressFlate(t, flate.DefaultCompression)
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip with NoCompression", func(t *testing.T) {
|
||
|
|
compressAndDecompressFlate(t, flate.NoCompression)
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip with BestSpeed", func(t *testing.T) {
|
||
|
|
compressAndDecompressFlate(t, flate.BestSpeed)
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip with BestCompression", func(t *testing.T) {
|
||
|
|
compressAndDecompressFlate(t, flate.BestCompression)
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip with HuffmanOnly", func(t *testing.T) {
|
||
|
|
compressAndDecompressFlate(t, flate.HuffmanOnly)
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Invalid compression level - too low", func(t *testing.T) {
|
||
|
|
_, err := NewFlateCompressorWithLevel(-3)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("NewFlateCompressorWithLevel(-3) expected error, got nil")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Invalid compression level - too high", func(t *testing.T) {
|
||
|
|
_, err := NewFlateCompressorWithLevel(10)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("NewFlateCompressorWithLevel(10) expected error, got nil")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Boundary valid levels", func(t *testing.T) {
|
||
|
|
// flate.NoCompression = -1, flate.BestCompression = 9
|
||
|
|
_, errLow := NewFlateCompressorWithLevel(flate.NoCompression)
|
||
|
|
if errLow != nil {
|
||
|
|
t.Errorf("NewFlateCompressorWithLevel(%d) unexpected error: %v", flate.NoCompression, errLow)
|
||
|
|
}
|
||
|
|
_, errHigh := NewFlateCompressorWithLevel(flate.BestCompression)
|
||
|
|
if errHigh != nil {
|
||
|
|
t.Errorf("NewFlateCompressorWithLevel(%d) unexpected error: %v", flate.BestCompression, errHigh)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Name", func(t *testing.T) {
|
||
|
|
c := NewFlateCompressor()
|
||
|
|
if got := c.Name(); got != "flate" {
|
||
|
|
t.Errorf("Compressor Name() = %q, want %q", got, "flate")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Init registers decompressor", func(t *testing.T) {
|
||
|
|
d, ok := Get("flate")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('flate') returned ok=false after init, want true")
|
||
|
|
}
|
||
|
|
if d.Name() != "flate" {
|
||
|
|
t.Errorf("Get('flate').Name() = %q, want %q", d.Name(), "flate")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// compressAndDecompressFlate is a helper for flate round-trip tests.
|
||
|
|
func compressAndDecompressFlate(t *testing.T, level int) {
|
||
|
|
t.Helper()
|
||
|
|
|
||
|
|
var compressed bytes.Buffer
|
||
|
|
|
||
|
|
c, err := NewFlateCompressorWithLevel(level)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("NewFlateCompressorWithLevel(%d) error = %v", level, err)
|
||
|
|
}
|
||
|
|
writer, err := c.Writer(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Writer() error = %v", err)
|
||
|
|
}
|
||
|
|
n, err := writer.Write(testData)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Write() error = %v", err)
|
||
|
|
}
|
||
|
|
if n != len(testData) {
|
||
|
|
t.Errorf("Write() wrote %d bytes, want %d", n, len(testData))
|
||
|
|
}
|
||
|
|
if err := writer.Close(); err != nil {
|
||
|
|
t.Fatalf("Close() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
d := NewFlateDecompressor()
|
||
|
|
reader, err := d.Reader(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("FlateDecompressor.Reader() error = %v", err)
|
||
|
|
}
|
||
|
|
decompressed, err := io.ReadAll(reader)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ReadAll() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
if !bytes.Equal(decompressed, testData) {
|
||
|
|
t.Fatalf("Level %d: decompressed data mismatch:\ngot: %q\nwant: %q",
|
||
|
|
level, string(decompressed), string(testData))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Zlib Round-trip Test
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestZlibDecompressor(t *testing.T) {
|
||
|
|
t.Run("Name", func(t *testing.T) {
|
||
|
|
d := NewZlibDecompressor()
|
||
|
|
if got := d.Name(); got != "zlib" {
|
||
|
|
t.Errorf("Name() = %q, want %q", got, "zlib")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandle deflate (HTTP Content-Encoding)", func(t *testing.T) {
|
||
|
|
d := NewZlibDecompressor()
|
||
|
|
if !d.CanHandle("deflate") {
|
||
|
|
t.Error("CanHandle('deflate') = false, want true (zlib handles 'deflate' encoding)")
|
||
|
|
}
|
||
|
|
if d.CanHandle("gzip") {
|
||
|
|
t.Error("CanHandle('gzip') = true, want false")
|
||
|
|
}
|
||
|
|
if d.CanHandle("") {
|
||
|
|
t.Error("CanHandle('') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile", func(t *testing.T) {
|
||
|
|
d := NewZlibDecompressor()
|
||
|
|
if !d.CanHandleFile("file.zlib") {
|
||
|
|
t.Error("CanHandleFile('file.zlib') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.zz") {
|
||
|
|
t.Error("CanHandleFile('file.zz') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.ZLIB") {
|
||
|
|
t.Error("CanHandleFile('file.ZLIB') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file.gz") {
|
||
|
|
t.Error("CanHandleFile('file.gz') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip compress/decompress", func(t *testing.T) {
|
||
|
|
var compressed bytes.Buffer
|
||
|
|
|
||
|
|
c := NewZlibCompressor()
|
||
|
|
writer, err := c.Writer(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ZlibCompressor.Writer() error = %v", err)
|
||
|
|
}
|
||
|
|
n, err := writer.Write(testData)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Write() error = %v", err)
|
||
|
|
}
|
||
|
|
if n != len(testData) {
|
||
|
|
t.Errorf("Write() wrote %d bytes, want %d", n, len(testData))
|
||
|
|
}
|
||
|
|
if err := writer.Close(); err != nil {
|
||
|
|
t.Fatalf("Close() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
d := NewZlibDecompressor()
|
||
|
|
reader, err := d.Reader(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ZlibDecompressor.Reader() error = %v", err)
|
||
|
|
}
|
||
|
|
decompressed, err := io.ReadAll(reader)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ReadAll() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
if !bytes.Equal(decompressed, testData) {
|
||
|
|
t.Fatalf("Decompressed data mismatch:\ngot: %q\nwant: %q",
|
||
|
|
string(decompressed), string(testData))
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Decompress with invalid data", func(t *testing.T) {
|
||
|
|
d := NewZlibDecompressor()
|
||
|
|
_, err := d.Reader(strings.NewReader("not zlib data"))
|
||
|
|
if err == nil {
|
||
|
|
t.Error("ZlibDecompressor.Reader() with invalid data expected error, got nil")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Name", func(t *testing.T) {
|
||
|
|
c := NewZlibCompressor()
|
||
|
|
if got := c.Name(); got != "zlib" {
|
||
|
|
t.Errorf("Compressor Name() = %q, want %q", got, "zlib")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Init registers decompressor", func(t *testing.T) {
|
||
|
|
d, ok := Get("zlib")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('zlib') returned ok=false after init, want true")
|
||
|
|
}
|
||
|
|
if d.Name() != "zlib" {
|
||
|
|
t.Errorf("Get('zlib').Name() = %q, want %q", d.Name(), "zlib")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// LZW Round-trip Test
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestLzwDecompressor(t *testing.T) {
|
||
|
|
t.Run("Name with LSB (default)", func(t *testing.T) {
|
||
|
|
d := NewLzwDecompressor()
|
||
|
|
if got := d.Name(); got != "lzw" {
|
||
|
|
t.Errorf("Name() = %q, want %q", got, "lzw")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Name with MSB", func(t *testing.T) {
|
||
|
|
d := NewLzwDecompressorWithOrder(lzw.MSB)
|
||
|
|
if got := d.Name(); got != "lzw-msb" {
|
||
|
|
t.Errorf("Name() with MSB = %q, want %q", got, "lzw-msb")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile", func(t *testing.T) {
|
||
|
|
d := NewLzwDecompressor()
|
||
|
|
if !d.CanHandleFile("file.Z") {
|
||
|
|
t.Error("CanHandleFile('file.Z') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.lzw") {
|
||
|
|
t.Error("CanHandleFile('file.lzw') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.LZW") {
|
||
|
|
t.Error("CanHandleFile('file.LZW') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file.gz") {
|
||
|
|
t.Error("CanHandleFile('file.gz') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip LSB (default)", func(t *testing.T) {
|
||
|
|
var compressed bytes.Buffer
|
||
|
|
|
||
|
|
c := NewLzwCompressor() // LSB by default
|
||
|
|
writer, err := c.Writer(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("LzwCompressor.Writer() error = %v", err)
|
||
|
|
}
|
||
|
|
n, err := writer.Write(testData)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Write() error = %v", err)
|
||
|
|
}
|
||
|
|
if n != len(testData) {
|
||
|
|
t.Errorf("Write() wrote %d bytes, want %d", n, len(testData))
|
||
|
|
}
|
||
|
|
if err := writer.Close(); err != nil {
|
||
|
|
t.Fatalf("Close() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
d := NewLzwDecompressor() // LSB by default
|
||
|
|
reader, err := d.Reader(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("LzwDecompressor.Reader() error = %v", err)
|
||
|
|
}
|
||
|
|
decompressed, err := io.ReadAll(reader)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ReadAll() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
if !bytes.Equal(decompressed, testData) {
|
||
|
|
t.Fatalf("Decompressed data mismatch:\ngot: %q\nwant: %q",
|
||
|
|
string(decompressed), string(testData))
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("RoundTrip MSB", func(t *testing.T) {
|
||
|
|
var compressed bytes.Buffer
|
||
|
|
|
||
|
|
c := NewLzwCompressorWithOrder(lzw.MSB)
|
||
|
|
writer, err := c.Writer(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("LzwCompressor(MSB).Writer() error = %v", err)
|
||
|
|
}
|
||
|
|
_, err = writer.Write(testData)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Write() error = %v", err)
|
||
|
|
}
|
||
|
|
if err := writer.Close(); err != nil {
|
||
|
|
t.Fatalf("Close() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
d := NewLzwDecompressorWithOrder(lzw.MSB)
|
||
|
|
reader, err := d.Reader(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("LzwDecompressor(MSB).Reader() error = %v", err)
|
||
|
|
}
|
||
|
|
decompressed, err := io.ReadAll(reader)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("ReadAll() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
if !bytes.Equal(decompressed, testData) {
|
||
|
|
t.Fatalf("Decompressed data mismatch:\ngot: %q\nwant: %q",
|
||
|
|
string(decompressed), string(testData))
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Decompress LSB with MSB reader fails", func(t *testing.T) {
|
||
|
|
var compressed bytes.Buffer
|
||
|
|
|
||
|
|
c := NewLzwCompressorWithOrder(lzw.MSB)
|
||
|
|
writer, _ := c.Writer(&compressed)
|
||
|
|
writer.Write(testData)
|
||
|
|
writer.Close()
|
||
|
|
|
||
|
|
d := NewLzwDecompressor() // LSB reader
|
||
|
|
reader, err := d.Reader(&compressed)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("LzwDecompressor.Reader() unexpected error = %v", err)
|
||
|
|
}
|
||
|
|
_, err = io.ReadAll(reader)
|
||
|
|
// This should fail because we compressed with MSB but decompress with LSB
|
||
|
|
if err == nil {
|
||
|
|
t.Log("Note: LZW MSB-compressed data with LSB reader did not error (may produce garbage)")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Name LSB", func(t *testing.T) {
|
||
|
|
c := NewLzwCompressor()
|
||
|
|
if got := c.Name(); got != "lzw" {
|
||
|
|
t.Errorf("Compressor Name() = %q, want %q", got, "lzw")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Name MSB", func(t *testing.T) {
|
||
|
|
c := NewLzwCompressorWithOrder(lzw.MSB)
|
||
|
|
if got := c.Name(); got != "lzw-msb" {
|
||
|
|
t.Errorf("Compressor Name() with MSB = %q, want %q", got, "lzw-msb")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Init registers decompressor", func(t *testing.T) {
|
||
|
|
d, ok := Get("lzw")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('lzw') returned ok=false after init, want true")
|
||
|
|
}
|
||
|
|
if d.Name() != "lzw" {
|
||
|
|
t.Errorf("Get('lzw').Name() = %q, want %q", d.Name(), "lzw")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Bzip2 Decompressor Tests
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
func TestBzip2Decompressor(t *testing.T) {
|
||
|
|
t.Run("NewBzip2Decompressor returns non-nil", func(t *testing.T) {
|
||
|
|
d := NewBzip2Decompressor()
|
||
|
|
if d == nil {
|
||
|
|
t.Fatal("NewBzip2Decompressor() returned nil")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Name", func(t *testing.T) {
|
||
|
|
d := NewBzip2Decompressor()
|
||
|
|
if got := d.Name(); got != "bzip2" {
|
||
|
|
t.Errorf("Name() = %q, want %q", got, "bzip2")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandle", func(t *testing.T) {
|
||
|
|
d := NewBzip2Decompressor()
|
||
|
|
if !d.CanHandle("bzip2") {
|
||
|
|
t.Error("CanHandle('bzip2') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandle("BZIP2") {
|
||
|
|
t.Error("CanHandle('BZIP2') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandle("Bzip2") {
|
||
|
|
t.Error("CanHandle('Bzip2') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandle("gzip") {
|
||
|
|
t.Error("CanHandle('gzip') = true, want false")
|
||
|
|
}
|
||
|
|
if d.CanHandle("") {
|
||
|
|
t.Error("CanHandle('') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("CanHandleFile", func(t *testing.T) {
|
||
|
|
d := NewBzip2Decompressor()
|
||
|
|
if !d.CanHandleFile("file.bz2") {
|
||
|
|
t.Error("CanHandleFile('file.bz2') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.tbz") {
|
||
|
|
t.Error("CanHandleFile('file.tbz') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.tbz2") {
|
||
|
|
t.Error("CanHandleFile('file.tbz2') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.BZ2") {
|
||
|
|
t.Error("CanHandleFile('file.BZ2') = false, want true")
|
||
|
|
}
|
||
|
|
if !d.CanHandleFile("file.TBZ") {
|
||
|
|
t.Error("CanHandleFile('file.TBZ') = false, want true")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file.gz") {
|
||
|
|
t.Error("CanHandleFile('file.gz') = true, want false")
|
||
|
|
}
|
||
|
|
if d.CanHandleFile("file") {
|
||
|
|
t.Error("CanHandleFile('file') = true, want false")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Reader returns a valid io.Reader for any input", func(t *testing.T) {
|
||
|
|
// bzip2.NewReader wraps the reader lazily and never returns an error.
|
||
|
|
// It will only error on the first Read() call if the data is invalid.
|
||
|
|
d := NewBzip2Decompressor()
|
||
|
|
reader, err := d.Reader(strings.NewReader("not real bzip2 data"))
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Bzip2Decompressor.Reader() unexpected error = %v", err)
|
||
|
|
}
|
||
|
|
if reader == nil {
|
||
|
|
t.Fatal("Bzip2Decompressor.Reader() returned nil reader")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Name", func(t *testing.T) {
|
||
|
|
c := NewBzip2Compressor()
|
||
|
|
if got := c.Name(); got != "bzip2" {
|
||
|
|
t.Errorf("Compressor Name() = %q, want %q", got, "bzip2")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Compressor Writer returns error (not in stdlib)", func(t *testing.T) {
|
||
|
|
c := NewBzip2Compressor()
|
||
|
|
var buf bytes.Buffer
|
||
|
|
_, err := c.Writer(&buf)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("Bzip2Compressor.Writer() expected error, got nil")
|
||
|
|
}
|
||
|
|
if err.Error() == "" {
|
||
|
|
t.Error("Bzip2Compressor.Writer() error message should not be empty")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
t.Run("Init registers decompressor", func(t *testing.T) {
|
||
|
|
d, ok := Get("bzip2")
|
||
|
|
if !ok {
|
||
|
|
t.Fatal("Get('bzip2') returned ok=false after init, want true")
|
||
|
|
}
|
||
|
|
if d.Name() != "bzip2" {
|
||
|
|
t.Errorf("Get('bzip2').Name() = %q, want %q", d.Name(), "bzip2")
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Helper Functions
|
||
|
|
// ============================================================================
|
||
|
|
|
||
|
|
// stringSliceEqual reports whether two string slices are equal.
|
||
|
|
func stringSliceEqual(a, b []string) bool {
|
||
|
|
if len(a) != len(b) {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
for i := range a {
|
||
|
|
if a[i] != b[i] {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestDecompressorReaderIsClosable is a regression guard for the BACKLOG
|
||
|
|
// entry "Gzip/zlib/flate/lzw Close() never called on decompressor". The
|
||
|
|
// previous Decompressor.Reader interface returned io.Reader, so the
|
||
|
|
// Close method on *gzip.Reader, *zlib.Reader, *flate.Reader and
|
||
|
|
// *lzw.Reader was lost at the API boundary. Callers could not release
|
||
|
|
// the decompressor's internal state, so a long-lived mirror scan over
|
||
|
|
// many .gz assets would accumulate decoder tables without bound.
|
||
|
|
//
|
||
|
|
// Verify that the new interface (io.ReadCloser) is honoured: each
|
||
|
|
// decompressor's reader exposes a working Close, calling it after
|
||
|
|
// reading must not panic, and double-close must also be safe.
|
||
|
|
func TestDecompressorReaderIsClosable(t *testing.T) {
|
||
|
|
decs := []Decompressor{
|
||
|
|
NewGzipDecompressor(),
|
||
|
|
NewZlibDecompressor(),
|
||
|
|
NewFlateDecompressor(),
|
||
|
|
NewLzwDecompressor(),
|
||
|
|
NewBzip2Decompressor(),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Each decompressor is given the *identity* input (just enough to
|
||
|
|
// satisfy NewReader for the formats that need a header — gzip, zlib,
|
||
|
|
// lzw, bzip2). We only care about Close behaviour, not actual
|
||
|
|
// decompression output, so identity input is enough for the
|
||
|
|
// constructor; we never call Read.
|
||
|
|
for _, dec := range decs {
|
||
|
|
t.Run(dec.Name(), func(t *testing.T) {
|
||
|
|
reader, err := dec.Reader(strings.NewReader(""))
|
||
|
|
if err != nil {
|
||
|
|
// NewReader on identity input may fail for some formats
|
||
|
|
// (e.g. gzip requires a valid header). That's fine — the
|
||
|
|
// test only asserts that, *whenever* we get a reader
|
||
|
|
// back, it is safely Close-able.
|
||
|
|
t.Logf("Reader returned err=%v (acceptable for empty input); skipping close check", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if reader == nil {
|
||
|
|
t.Fatal("Reader returned nil reader")
|
||
|
|
}
|
||
|
|
// First Close: must not panic.
|
||
|
|
if err := reader.Close(); err != nil {
|
||
|
|
t.Errorf("first Close returned err=%v, want nil", err)
|
||
|
|
}
|
||
|
|
// Second Close: many stdlib readers return nil or a
|
||
|
|
// documented sentinel on second close; we just require no
|
||
|
|
// panic.
|
||
|
|
defer func() {
|
||
|
|
if r := recover(); r != nil {
|
||
|
|
t.Errorf("second Close panicked: %v", r)
|
||
|
|
}
|
||
|
|
}()
|
||
|
|
_ = reader.Close()
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|