1// Copyright 2011 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package lzw
6
7import (
8	"bytes"
9	"fmt"
10	"internal/testenv"
11	"io"
12	"math"
13	"os"
14	"runtime"
15	"testing"
16)
17
18var filenames = []string{
19	"../testdata/gettysburg.txt",
20	"../testdata/e.txt",
21	"../testdata/pi.txt",
22}
23
24// testFile tests that compressing and then decompressing the given file with
25// the given options yields equivalent bytes to the original file.
26func testFile(t *testing.T, fn string, order Order, litWidth int) {
27	// Read the file, as golden output.
28	golden, err := os.Open(fn)
29	if err != nil {
30		t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err)
31		return
32	}
33	defer golden.Close()
34
35	// Read the file again, and push it through a pipe that compresses at the write end, and decompresses at the read end.
36	raw, err := os.Open(fn)
37	if err != nil {
38		t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err)
39		return
40	}
41
42	piper, pipew := io.Pipe()
43	defer piper.Close()
44	go func() {
45		defer raw.Close()
46		defer pipew.Close()
47		lzww := NewWriter(pipew, order, litWidth)
48		defer lzww.Close()
49		var b [4096]byte
50		for {
51			n, err0 := raw.Read(b[:])
52			if err0 != nil && err0 != io.EOF {
53				t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err0)
54				return
55			}
56			_, err1 := lzww.Write(b[:n])
57			if err1 != nil {
58				t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err1)
59				return
60			}
61			if err0 == io.EOF {
62				break
63			}
64		}
65	}()
66	lzwr := NewReader(piper, order, litWidth)
67	defer lzwr.Close()
68
69	// Compare the two.
70	b0, err0 := io.ReadAll(golden)
71	b1, err1 := io.ReadAll(lzwr)
72	if err0 != nil {
73		t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err0)
74		return
75	}
76	if err1 != nil {
77		t.Errorf("%s (order=%d litWidth=%d): %v", fn, order, litWidth, err1)
78		return
79	}
80	if len(b1) != len(b0) {
81		t.Errorf("%s (order=%d litWidth=%d): length mismatch %d != %d", fn, order, litWidth, len(b1), len(b0))
82		return
83	}
84	for i := 0; i < len(b0); i++ {
85		if b1[i] != b0[i] {
86			t.Errorf("%s (order=%d litWidth=%d): mismatch at %d, 0x%02x != 0x%02x\n", fn, order, litWidth, i, b1[i], b0[i])
87			return
88		}
89	}
90}
91
92func TestWriter(t *testing.T) {
93	for _, filename := range filenames {
94		for _, order := range [...]Order{LSB, MSB} {
95			// The test data "2.71828 etcetera" is ASCII text requiring at least 6 bits.
96			for litWidth := 6; litWidth <= 8; litWidth++ {
97				if filename == "../testdata/gettysburg.txt" && litWidth == 6 {
98					continue
99				}
100				testFile(t, filename, order, litWidth)
101			}
102		}
103		if testing.Short() && testenv.Builder() == "" {
104			break
105		}
106	}
107}
108
109func TestWriterReset(t *testing.T) {
110	for _, order := range [...]Order{LSB, MSB} {
111		t.Run(fmt.Sprintf("Order %d", order), func(t *testing.T) {
112			for litWidth := 6; litWidth <= 8; litWidth++ {
113				t.Run(fmt.Sprintf("LitWidth %d", litWidth), func(t *testing.T) {
114					var data []byte
115					if litWidth == 6 {
116						data = []byte{1, 2, 3}
117					} else {
118						data = []byte(`lorem ipsum dolor sit amet`)
119					}
120					var buf bytes.Buffer
121					w := NewWriter(&buf, order, litWidth)
122					if _, err := w.Write(data); err != nil {
123						t.Errorf("write: %v: %v", string(data), err)
124					}
125
126					if err := w.Close(); err != nil {
127						t.Errorf("close: %v", err)
128					}
129
130					b1 := buf.Bytes()
131					buf.Reset()
132
133					w.(*Writer).Reset(&buf, order, litWidth)
134
135					if _, err := w.Write(data); err != nil {
136						t.Errorf("write: %v: %v", string(data), err)
137					}
138
139					if err := w.Close(); err != nil {
140						t.Errorf("close: %v", err)
141					}
142					b2 := buf.Bytes()
143
144					if !bytes.Equal(b1, b2) {
145						t.Errorf("bytes written were not same")
146					}
147				})
148			}
149		})
150	}
151}
152
153func TestWriterReturnValues(t *testing.T) {
154	w := NewWriter(io.Discard, LSB, 8)
155	n, err := w.Write([]byte("asdf"))
156	if n != 4 || err != nil {
157		t.Errorf("got %d, %v, want 4, nil", n, err)
158	}
159}
160
161func TestSmallLitWidth(t *testing.T) {
162	w := NewWriter(io.Discard, LSB, 2)
163	if _, err := w.Write([]byte{0x03}); err != nil {
164		t.Fatalf("write a byte < 1<<2: %v", err)
165	}
166	if _, err := w.Write([]byte{0x04}); err == nil {
167		t.Fatal("write a byte >= 1<<2: got nil error, want non-nil")
168	}
169}
170
171func TestStartsWithClearCode(t *testing.T) {
172	// A literal width of 7 bits means that the code width starts at 8 bits,
173	// which makes it easier to visually inspect the output (provided that the
174	// output is short so codes don't get longer). Each byte is a code:
175	//  - ASCII bytes are literal codes,
176	//  - 0x80 is the clear code,
177	//  - 0x81 is the end code.
178	//  - 0x82 and above are copy codes (unused in this test case).
179	for _, empty := range []bool{false, true} {
180		var buf bytes.Buffer
181		w := NewWriter(&buf, LSB, 7)
182		if !empty {
183			w.Write([]byte("Hi"))
184		}
185		w.Close()
186		got := buf.String()
187
188		want := "\x80\x81"
189		if !empty {
190			want = "\x80Hi\x81"
191		}
192
193		if got != want {
194			t.Errorf("empty=%t: got %q, want %q", empty, got, want)
195		}
196	}
197}
198
199func BenchmarkEncoder(b *testing.B) {
200	buf, err := os.ReadFile("../testdata/e.txt")
201	if err != nil {
202		b.Fatal(err)
203	}
204	if len(buf) == 0 {
205		b.Fatalf("test file has no data")
206	}
207
208	for e := 4; e <= 6; e++ {
209		n := int(math.Pow10(e))
210		buf0 := buf
211		buf1 := make([]byte, n)
212		for i := 0; i < n; i += len(buf0) {
213			if len(buf0) > n-i {
214				buf0 = buf0[:n-i]
215			}
216			copy(buf1[i:], buf0)
217		}
218		buf0 = nil
219		runtime.GC()
220		b.Run(fmt.Sprint("1e", e), func(b *testing.B) {
221			b.SetBytes(int64(n))
222			for i := 0; i < b.N; i++ {
223				w := NewWriter(io.Discard, LSB, 8)
224				w.Write(buf1)
225				w.Close()
226			}
227		})
228		b.Run(fmt.Sprint("1e-Reuse", e), func(b *testing.B) {
229			b.SetBytes(int64(n))
230			w := NewWriter(io.Discard, LSB, 8)
231			for i := 0; i < b.N; i++ {
232				w.Write(buf1)
233				w.Close()
234				w.(*Writer).Reset(io.Discard, LSB, 8)
235			}
236		})
237	}
238}
239