1// Copyright 2011 The Go Authors. All rights reserved.2// Use of this source code is governed by a BSD-style3// license that can be found in the LICENSE file.45// Tests that involve both reading and writing.67package zip89import (10	"bytes"11	"cmp"12	"errors"13	"fmt"14	"hash"15	"internal/testenv"16	"io"17	"math/bits"18	"slices"19	"strings"20	"testing"21	"time"22)2324func TestOver65kFiles(t *testing.T) {25	if testing.Short() && testenv.Builder() == "" {26		t.Skip("skipping in short mode")27	}28	buf := new(strings.Builder)29	w := NewWriter(buf)30	const nFiles = (1 << 16) + 4231	for i := 0; i < nFiles; i++ {32		_, err := w.CreateHeader(&FileHeader{33			Name:   fmt.Sprintf("%d.dat", i),34			Method: Store, // Deflate is too slow when it is compiled with -race flag35		})36		if err != nil {37			t.Fatalf("creating file %d: %v", i, err)38		}39	}40	if err := w.Close(); err != nil {41		t.Fatalf("Writer.Close: %v", err)42	}43	s := buf.String()44	zr, err := NewReader(strings.NewReader(s), int64(len(s)))45	if err != nil {46		t.Fatalf("NewReader: %v", err)47	}48	if got := len(zr.File); got != nFiles {49		t.Fatalf("File contains %d files, want %d", got, nFiles)50	}51	for i := 0; i < nFiles; i++ {52		want := fmt.Sprintf("%d.dat", i)53		if zr.File[i].Name != want {54			t.Fatalf("File(%d) = %q, want %q", i, zr.File[i].Name, want)55		}56	}57}5859func TestModTime(t *testing.T) {60	var testTime = time.Date(2009, time.November, 10, 23, 45, 58, 0, time.UTC)61	fh := new(FileHeader)62	fh.SetModTime(testTime)63	outTime := fh.ModTime()64	if !outTime.Equal(testTime) {65		t.Errorf("times don't match: got %s, want %s", outTime, testTime)66	}67}6869func testHeaderRoundTrip(fh *FileHeader, wantUncompressedSize uint32, wantUncompressedSize64 uint64, t *testing.T) {70	fi := fh.FileInfo()71	fh2, err := FileInfoHeader(fi)72	if err != nil {73		t.Fatal(err)74	}75	if got, want := fh2.Name, fh.Name; got != want {76		t.Errorf("Name: got %s, want %s\n", got, want)77	}78	if got, want := fh2.UncompressedSize, wantUncompressedSize; got != want {79		t.Errorf("UncompressedSize: got %d, want %d\n", got, want)80	}81	if got, want := fh2.UncompressedSize64, wantUncompressedSize64; got != want {82		t.Errorf("UncompressedSize64: got %d, want %d\n", got, want)83	}84	if got, want := fh2.ModifiedTime, fh.ModifiedTime; got != want {85		t.Errorf("ModifiedTime: got %d, want %d\n", got, want)86	}87	if got, want := fh2.ModifiedDate, fh.ModifiedDate; got != want {88		t.Errorf("ModifiedDate: got %d, want %d\n", got, want)89	}9091	if sysfh, ok := fi.Sys().(*FileHeader); !ok && sysfh != fh {92		t.Errorf("Sys didn't return original *FileHeader")93	}94}9596func TestFileHeaderRoundTrip(t *testing.T) {97	fh := &FileHeader{98		Name:             "foo.txt",99		UncompressedSize: 987654321,100		ModifiedTime:     1234,101		ModifiedDate:     5678,102	}103	testHeaderRoundTrip(fh, fh.UncompressedSize, uint64(fh.UncompressedSize), t)104}105106func TestFileHeaderRoundTrip64(t *testing.T) {107	fh := &FileHeader{108		Name:               "foo.txt",109		UncompressedSize64: 9876543210,110		ModifiedTime:       1234,111		ModifiedDate:       5678,112	}113	testHeaderRoundTrip(fh, uint32max, fh.UncompressedSize64, t)114}115116func TestFileHeaderRoundTripModified(t *testing.T) {117	fh := &FileHeader{118		Name:             "foo.txt",119		UncompressedSize: 987654321,120		Modified:         time.Now().Local(),121		ModifiedTime:     1234,122		ModifiedDate:     5678,123	}124	fi := fh.FileInfo()125	fh2, err := FileInfoHeader(fi)126	if err != nil {127		t.Fatal(err)128	}129	if got, want := fh2.Modified, fh.Modified.UTC(); got != want {130		t.Errorf("Modified: got %s, want %s\n", got, want)131	}132	if got, want := fi.ModTime(), fh.Modified.UTC(); got != want {133		t.Errorf("Modified: got %s, want %s\n", got, want)134	}135}136137func TestFileHeaderRoundTripWithoutModified(t *testing.T) {138	fh := &FileHeader{139		Name:             "foo.txt",140		UncompressedSize: 987654321,141		ModifiedTime:     1234,142		ModifiedDate:     5678,143	}144	fi := fh.FileInfo()145	fh2, err := FileInfoHeader(fi)146	if err != nil {147		t.Fatal(err)148	}149	if got, want := fh2.ModTime(), fh.ModTime(); got != want {150		t.Errorf("Modified: got %s, want %s\n", got, want)151	}152	if got, want := fi.ModTime(), fh.ModTime(); got != want {153		t.Errorf("Modified: got %s, want %s\n", got, want)154	}155}156157type repeatedByte struct {158	off int64159	b   byte160	n   int64161}162163// rleBuffer is a run-length-encoded byte buffer.164// It's an io.Writer (like a bytes.Buffer) and also an io.ReaderAt,165// allowing random-access reads.166type rleBuffer struct {167	buf []repeatedByte168}169170func (r *rleBuffer) Size() int64 {171	if len(r.buf) == 0 {172		return 0173	}174	last := &r.buf[len(r.buf)-1]175	return last.off + last.n176}177178func (r *rleBuffer) Write(p []byte) (n int, err error) {179	var rp *repeatedByte180	if len(r.buf) > 0 {181		rp = &r.buf[len(r.buf)-1]182		// Fast path, if p is entirely the same byte repeated.183		if lastByte := rp.b; len(p) > 0 && p[0] == lastByte {184			if bytes.Count(p, []byte{lastByte}) == len(p) {185				rp.n += int64(len(p))186				return len(p), nil187			}188		}189	}190191	for _, b := range p {192		if rp == nil || rp.b != b {193			r.buf = append(r.buf, repeatedByte{r.Size(), b, 1})194			rp = &r.buf[len(r.buf)-1]195		} else {196			rp.n++197		}198	}199	return len(p), nil200}201202func memset(a []byte, b byte) {203	if len(a) == 0 {204		return205	}206	// Double, until we reach power of 2 >= len(a), same as bytes.Repeat,207	// but without allocation.208	a[0] = b209	for i, l := 1, len(a); i < l; i *= 2 {210		copy(a[i:], a[:i])211	}212}213214func (r *rleBuffer) ReadAt(p []byte, off int64) (n int, err error) {215	if len(p) == 0 {216		return217	}218	skipParts, _ := slices.BinarySearchFunc(r.buf, off, func(rb repeatedByte, off int64) int {219		return cmp.Compare(rb.off+rb.n, off)220	})221	parts := r.buf[skipParts:]222	if len(parts) > 0 {223		skipBytes := off - parts[0].off224		for _, part := range parts {225			repeat := int(min(part.n-skipBytes, int64(len(p)-n)))226			memset(p[n:n+repeat], part.b)227			n += repeat228			if n == len(p) {229				return230			}231			skipBytes = 0232		}233	}234	if n != len(p) {235		err = io.ErrUnexpectedEOF236	}237	return238}239240// Just testing the rleBuffer used in the Zip64 test above. Not used by the zip code.241func TestRLEBuffer(t *testing.T) {242	b := new(rleBuffer)243	var all []byte244	writes := []string{"abcdeee", "eeeeeee", "eeeefghaaiii"}245	for _, w := range writes {246		b.Write([]byte(w))247		all = append(all, w...)248	}249	if len(b.buf) != 10 {250		t.Fatalf("len(b.buf) = %d; want 10", len(b.buf))251	}252253	for i := 0; i < len(all); i++ {254		for j := 0; j < len(all)-i; j++ {255			buf := make([]byte, j)256			n, err := b.ReadAt(buf, int64(i))257			if err != nil || n != len(buf) {258				t.Errorf("ReadAt(%d, %d) = %d, %v; want %d, nil", i, j, n, err, len(buf))259			}260			if !bytes.Equal(buf, all[i:i+j]) {261				t.Errorf("ReadAt(%d, %d) = %q; want %q", i, j, buf, all[i:i+j])262			}263		}264	}265}266267// fakeHash32 is a dummy Hash32 that always returns 0.268type fakeHash32 struct {269	hash.Hash32270}271272func (fakeHash32) Write(p []byte) (int, error) { return len(p), nil }273func (fakeHash32) Sum32() uint32               { return 0 }274275func TestZip64(t *testing.T) {276	if testing.Short() {277		t.Skip("slow test; skipping")278	}279	t.Parallel()280	const size = 1 << 32 // before the "END\n" part281	buf := testZip64(t, size)282	testZip64DirectoryRecordLength(buf, t)283}284285func TestZip64EdgeCase(t *testing.T) {286	if testing.Short() {287		t.Skip("slow test; skipping")288	}289	t.Parallel()290	// Test a zip file with uncompressed size 0xFFFFFFFF.291	// That's the magic marker for a 64-bit file, so even though292	// it fits in a 32-bit field we must use the 64-bit field.293	// Go 1.5 and earlier got this wrong,294	// writing an invalid zip file.295	const size = 1<<32 - 1 - int64(len("END\n")) // before the "END\n" part296	buf := testZip64(t, size)297	testZip64DirectoryRecordLength(buf, t)298}299300// Tests that we generate a zip64 file if the directory at offset301// 0xFFFFFFFF, but not before.302func TestZip64DirectoryOffset(t *testing.T) {303	if testing.Short() {304		t.Skip("skipping in short mode")305	}306	t.Parallel()307	const filename = "huge.txt"308	gen := func(wantOff uint64) func(*Writer) {309		return func(w *Writer) {310			w.testHookCloseSizeOffset = func(size, off uint64) {311				if off != wantOff {312					t.Errorf("central directory offset = %d (%x); want %d", off, off, wantOff)313				}314			}315			f, err := w.CreateHeader(&FileHeader{316				Name:   filename,317				Method: Store,318			})319			if err != nil {320				t.Fatal(err)321			}322			f.(*fileWriter).crc32 = fakeHash32{}323			size := wantOff - fileHeaderLen - uint64(len(filename)) - dataDescriptorLen324			if _, err := io.CopyN(f, zeros{}, int64(size)); err != nil {325				t.Fatal(err)326			}327			if err := w.Close(); err != nil {328				t.Fatal(err)329			}330		}331	}332	t.Run("uint32max-2_NoZip64", func(t *testing.T) {333		t.Parallel()334		if generatesZip64(t, gen(0xfffffffe)) {335			t.Error("unexpected zip64")336		}337	})338	t.Run("uint32max-1_Zip64", func(t *testing.T) {339		t.Parallel()340		if !generatesZip64(t, gen(0xffffffff)) {341			t.Error("expected zip64")342		}343	})344}345346// At 16k records, we need to generate a zip64 file.347func TestZip64ManyRecords(t *testing.T) {348	if testing.Short() {349		t.Skip("skipping in short mode")350	}351	t.Parallel()352	gen := func(numRec int) func(*Writer) {353		return func(w *Writer) {354			for i := 0; i < numRec; i++ {355				_, err := w.CreateHeader(&FileHeader{356					Name:   "a.txt",357					Method: Store,358				})359				if err != nil {360					t.Fatal(err)361				}362			}363			if err := w.Close(); err != nil {364				t.Fatal(err)365			}366		}367	}368	// 16k-1 records shouldn't make a zip64:369	t.Run("uint16max-1_NoZip64", func(t *testing.T) {370		t.Parallel()371		if generatesZip64(t, gen(0xfffe)) {372			t.Error("unexpected zip64")373		}374	})375	// 16k records should make a zip64:376	t.Run("uint16max_Zip64", func(t *testing.T) {377		t.Parallel()378		if !generatesZip64(t, gen(0xffff)) {379			t.Error("expected zip64")380		}381	})382}383384// suffixSaver is an io.Writer & io.ReaderAt that remembers the last 0385// to 'keep' bytes of data written to it. Call Suffix to get the386// suffix bytes.387type suffixSaver struct {388	keep  int389	buf   []byte390	start int391	size  int64392}393394func (ss *suffixSaver) Size() int64 { return ss.size }395396var errDiscardedBytes = errors.New("ReadAt of discarded bytes")397398func (ss *suffixSaver) ReadAt(p []byte, off int64) (n int, err error) {399	back := ss.size - off400	if back > int64(ss.keep) {401		return 0, errDiscardedBytes402	}403	suf := ss.Suffix()404	n = copy(p, suf[len(suf)-int(back):])405	if n != len(p) {406		err = io.EOF407	}408	return409}410411func (ss *suffixSaver) Suffix() []byte {412	if len(ss.buf) < ss.keep {413		return ss.buf414	}415	buf := make([]byte, ss.keep)416	n := copy(buf, ss.buf[ss.start:])417	copy(buf[n:], ss.buf[:])418	return buf419}420421func (ss *suffixSaver) Write(p []byte) (n int, err error) {422	n = len(p)423	ss.size += int64(len(p))424	if len(ss.buf) < ss.keep {425		space := ss.keep - len(ss.buf)426		add := len(p)427		if add > space {428			add = space429		}430		ss.buf = append(ss.buf, p[:add]...)431		p = p[add:]432	}433	for len(p) > 0 {434		n := copy(ss.buf[ss.start:], p)435		p = p[n:]436		ss.start += n437		if ss.start == ss.keep {438			ss.start = 0439		}440	}441	return442}443444// generatesZip64 reports whether f wrote a zip64 file.445// f is also responsible for closing w.446func generatesZip64(t *testing.T, f func(w *Writer)) bool {447	ss := &suffixSaver{keep: 10 << 20}448	w := NewWriter(ss)449	f(w)450	return suffixIsZip64(t, ss)451}452453type sizedReaderAt interface {454	io.ReaderAt455	Size() int64456}457458func suffixIsZip64(t *testing.T, zip sizedReaderAt) bool {459	d := make([]byte, 1024)460	if _, err := zip.ReadAt(d, zip.Size()-int64(len(d))); err != nil {461		t.Fatalf("ReadAt: %v", err)462	}463464	sigOff := findSignatureInBlock(d)465	if sigOff == -1 {466		t.Errorf("failed to find signature in block")467		return false468	}469470	dirOff, err := findDirectory64End(zip, zip.Size()-int64(len(d))+int64(sigOff))471	if err != nil {472		t.Fatalf("findDirectory64End: %v", err)473	}474	if dirOff == -1 {475		return false476	}477478	d = make([]byte, directory64EndLen)479	if _, err := zip.ReadAt(d, dirOff); err != nil {480		t.Fatalf("ReadAt(off=%d): %v", dirOff, err)481	}482483	b := readBuf(d)484	if sig := b.uint32(); sig != directory64EndSignature {485		return false486	}487488	size := b.uint64()489	if size != directory64EndLen-12 {490		t.Errorf("expected length of %d, got %d", directory64EndLen-12, size)491	}492	return true493}494495// Zip64 is required if the total size of the records is uint32max.496func TestZip64LargeDirectory(t *testing.T) {497	if testenv.CPUIsSlow() {498		t.Skip("too slow")499	}500	if testing.Short() {501		t.Skip("skipping in short mode")502	}503	if bits.UintSize == 32 {504		t.Skip("skipping on 32-bit platforms")505	}506	t.Parallel()507	// gen returns a func that writes a zip with a wantLen bytes508	// of central directory.509	gen := func(wantLen int64) func(*Writer) {510		return func(w *Writer) {511			w.testHookCloseSizeOffset = func(size, off uint64) {512				if size != uint64(wantLen) {513					t.Errorf("Close central directory size = %d; want %d", size, wantLen)514				}515			}516517			uint16string := strings.Repeat(".", uint16max)518			remain := wantLen519			for remain > 0 {520				commentLen := int(uint16max) - directoryHeaderLen - 1521				thisRecLen := directoryHeaderLen + int(uint16max) + commentLen522				if int64(thisRecLen) > remain {523					remove := thisRecLen - int(remain)524					commentLen -= remove525					thisRecLen -= remove526				}527				remain -= int64(thisRecLen)528				f, err := w.CreateHeader(&FileHeader{529					Name:    uint16string,530					Comment: uint16string[:commentLen],531				})532				if err != nil {533					t.Fatalf("CreateHeader: %v", err)534				}535				f.(*fileWriter).crc32 = fakeHash32{}536			}537			if err := w.Close(); err != nil {538				t.Fatalf("Close: %v", err)539			}540		}541	}542	t.Run("uint32max-1_NoZip64", func(t *testing.T) {543		t.Parallel()544		buf := new(rleBuffer)545		w := NewWriter(buf)546		gen(uint32max - 1)(w)547		if suffixIsZip64(t, buf) {548			t.Error("unexpected zip64")549		}550		if _, err := NewReader(buf, buf.Size()); err != nil {551			t.Errorf("NewReader: %v", err)552		}553	})554	t.Run("uint32max_HasZip64", func(t *testing.T) {555		t.Parallel()556		buf := new(rleBuffer)557		w := NewWriter(buf)558		gen(uint32max)(w)559		if !suffixIsZip64(t, buf) {560			t.Error("expected zip64")561		}562		// Round-trip through NewReader. With CD size exactly 0xFFFFFFFF,563		// records well below 0xFFFF, and dirOffset == 0, the only EOCD564		// field that holds the placeholder is directorySize.565		if _, err := NewReader(buf, buf.Size()); err != nil {566			t.Errorf("NewReader: %v", err)567		}568	})569}570571func testZip64(t testing.TB, size int64) *rleBuffer {572	const chunkSize = 1024573	chunks := int(size / chunkSize)574	// write size bytes plus "END\n" to a zip file575	buf := new(rleBuffer)576	w := NewWriter(buf)577	f, err := w.CreateHeader(&FileHeader{578		Name:   "huge.txt",579		Method: Store,580	})581	if err != nil {582		t.Fatal(err)583	}584	f.(*fileWriter).crc32 = fakeHash32{}585	chunk := make([]byte, chunkSize)586	for i := range chunk {587		chunk[i] = '.'588	}589	for i := 0; i < chunks; i++ {590		_, err := f.Write(chunk)591		if err != nil {592			t.Fatal("write chunk:", err)593		}594	}595	if frag := int(size % chunkSize); frag > 0 {596		_, err := f.Write(chunk[:frag])597		if err != nil {598			t.Fatal("write chunk:", err)599		}600	}601	end := []byte("END\n")602	_, err = f.Write(end)603	if err != nil {604		t.Fatal("write end:", err)605	}606	if err := w.Close(); err != nil {607		t.Fatal(err)608	}609610	// read back zip file and check that we get to the end of it611	r, err := NewReader(buf, buf.Size())612	if err != nil {613		t.Fatal("reader:", err)614	}615	f0 := r.File[0]616	rc, err := f0.Open()617	if err != nil {618		t.Fatal("opening:", err)619	}620	rc.(*checksumReader).hash = fakeHash32{}621	for i := 0; i < chunks; i++ {622		_, err := io.ReadFull(rc, chunk)623		if err != nil {624			t.Fatal("read:", err)625		}626	}627	if frag := int(size % chunkSize); frag > 0 {628		_, err := io.ReadFull(rc, chunk[:frag])629		if err != nil {630			t.Fatal("read:", err)631		}632	}633	gotEnd, err := io.ReadAll(rc)634	if err != nil {635		t.Fatal("read end:", err)636	}637	if !bytes.Equal(gotEnd, end) {638		t.Errorf("End of zip64 archive %q, want %q", gotEnd, end)639	}640	err = rc.Close()641	if err != nil {642		t.Fatal("closing:", err)643	}644	if size+int64(len("END\n")) >= 1<<32-1 {645		if got, want := f0.UncompressedSize, uint32(uint32max); got != want {646			t.Errorf("UncompressedSize %#x, want %#x", got, want)647		}648	}649650	if got, want := f0.UncompressedSize64, uint64(size)+uint64(len(end)); got != want {651		t.Errorf("UncompressedSize64 %#x, want %#x", got, want)652	}653654	return buf655}656657// Issue 9857658func testZip64DirectoryRecordLength(buf *rleBuffer, t *testing.T) {659	if !suffixIsZip64(t, buf) {660		t.Fatal("not a zip64")661	}662}663664func testValidHeader(h *FileHeader, t *testing.T) {665	var buf bytes.Buffer666	z := NewWriter(&buf)667668	f, err := z.CreateHeader(h)669	if err != nil {670		t.Fatalf("error creating header: %v", err)671	}672	if _, err := f.Write([]byte("hi")); err != nil {673		t.Fatalf("error writing content: %v", err)674	}675	if err := z.Close(); err != nil {676		t.Fatalf("error closing zip writer: %v", err)677	}678679	b := buf.Bytes()680	zf, err := NewReader(bytes.NewReader(b), int64(len(b)))681	if err != nil {682		t.Fatalf("got %v, expected nil", err)683	}684	zh := zf.File[0].FileHeader685	if zh.Name != h.Name || zh.Method != h.Method || zh.UncompressedSize64 != uint64(len("hi")) {686		t.Fatalf("got %q/%d/%d expected %q/%d/%d", zh.Name, zh.Method, zh.UncompressedSize64, h.Name, h.Method, len("hi"))687	}688}689690// Issue 4302.691func TestHeaderInvalidTagAndSize(t *testing.T) {692	const timeFormat = "20060102T150405.000.txt"693694	ts := time.Now()695	filename := ts.Format(timeFormat)696697	h := FileHeader{698		Name:   filename,699		Method: Deflate,700		Extra:  []byte(ts.Format(time.RFC3339Nano)), // missing tag and len, but Extra is best-effort parsing701	}702	h.SetModTime(ts)703704	testValidHeader(&h, t)705}706707func TestHeaderTooShort(t *testing.T) {708	h := FileHeader{709		Name:   "foo.txt",710		Method: Deflate,711		Extra:  []byte{zip64ExtraID}, // missing size and second half of tag, but Extra is best-effort parsing712	}713	testValidHeader(&h, t)714}715716func TestHeaderTooLongErr(t *testing.T) {717	var headerTests = []struct {718		name    string719		extra   []byte720		wanterr error721	}{722		{723			name:    strings.Repeat("x", 1<<16),724			extra:   []byte{},725			wanterr: errLongName,726		},727		{728			name:    "long_extra",729			extra:   bytes.Repeat([]byte{0xff}, 1<<16),730			wanterr: errLongExtra,731		},732	}733734	// write a zip file735	buf := new(bytes.Buffer)736	w := NewWriter(buf)737738	for _, test := range headerTests {739		h := &FileHeader{740			Name:  test.name,741			Extra: test.extra,742		}743		_, err := w.CreateHeader(h)744		if err != test.wanterr {745			t.Errorf("error=%v, want %v", err, test.wanterr)746		}747	}748749	if err := w.Close(); err != nil {750		t.Fatal(err)751	}752}753754func TestHeaderIgnoredSize(t *testing.T) {755	h := FileHeader{756		Name:   "foo.txt",757		Method: Deflate,758		Extra:  []byte{zip64ExtraID & 0xFF, zip64ExtraID >> 8, 24, 0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}, // bad size but shouldn't be consulted759	}760	testValidHeader(&h, t)761}762763// Issue 4393. It is valid to have an extra data header764// which contains no body.765func TestZeroLengthHeader(t *testing.T) {766	h := FileHeader{767		Name:   "extadata.txt",768		Method: Deflate,769		Extra: []byte{770			85, 84, 5, 0, 3, 154, 144, 195, 77, // tag 21589 size 5771			85, 120, 0, 0, // tag 30805 size 0772		},773	}774	testValidHeader(&h, t)775}776777// Just benchmarking how fast the Zip64 test above is. Not related to778// our zip performance, since the test above disabled CRC32 and flate.779func BenchmarkZip64Test(b *testing.B) {780	for i := 0; i < b.N; i++ {781		testZip64(b, 1<<26)782	}783}784785func BenchmarkZip64TestSizes(b *testing.B) {786	for _, size := range []int64{1 << 12, 1 << 20, 1 << 26} {787		b.Run(fmt.Sprint(size), func(b *testing.B) {788			b.RunParallel(func(pb *testing.PB) {789				for pb.Next() {790					testZip64(b, size)791				}792			})793		})794	}795}796797func TestSuffixSaver(t *testing.T) {798	const keep = 10799	ss := &suffixSaver{keep: keep}800	ss.Write([]byte("abc"))801	if got := string(ss.Suffix()); got != "abc" {802		t.Errorf("got = %q; want abc", got)803	}804	ss.Write([]byte("defghijklmno"))805	if got := string(ss.Suffix()); got != "fghijklmno" {806		t.Errorf("got = %q; want fghijklmno", got)807	}808	if got, want := ss.Size(), int64(len("abc")+len("defghijklmno")); got != want {809		t.Errorf("Size = %d; want %d", got, want)810	}811	buf := make([]byte, ss.Size())812	for off := int64(0); off < ss.Size(); off++ {813		for size := 1; size <= int(ss.Size()-off); size++ {814			readBuf := buf[:size]815			n, err := ss.ReadAt(readBuf, off)816			if off < ss.Size()-keep {817				if err != errDiscardedBytes {818					t.Errorf("off %d, size %d = %v, %v (%q); want errDiscardedBytes", off, size, n, err, readBuf[:n])819				}820				continue821			}822			want := "abcdefghijklmno"[off : off+int64(size)]823			got := string(readBuf[:n])824			if err != nil || got != want {825				t.Errorf("off %d, size %d = %v, %v (%q); want %q", off, size, n, err, got, want)826			}827		}828	}829830}831832type zeros struct{}833834func (zeros) Read(p []byte) (int, error) {835	clear(p)836	return len(p), nil837}