Source file src/archive/zip/zip_test.go

     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  
     5  // Tests that involve both reading and writing.
     6  
     7  package zip
     8  
     9  import (
    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  )
    23  
    24  func 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) + 42
    31  	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 flag
    35  		})
    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  }
    58  
    59  func 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  }
    68  
    69  func 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  	}
    90  
    91  	if sysfh, ok := fi.Sys().(*FileHeader); !ok && sysfh != fh {
    92  		t.Errorf("Sys didn't return original *FileHeader")
    93  	}
    94  }
    95  
    96  func 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  }
   105  
   106  func 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  }
   115  
   116  func 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  }
   136  
   137  func 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  }
   156  
   157  type repeatedByte struct {
   158  	off int64
   159  	b   byte
   160  	n   int64
   161  }
   162  
   163  // 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.
   166  type rleBuffer struct {
   167  	buf []repeatedByte
   168  }
   169  
   170  func (r *rleBuffer) Size() int64 {
   171  	if len(r.buf) == 0 {
   172  		return 0
   173  	}
   174  	last := &r.buf[len(r.buf)-1]
   175  	return last.off + last.n
   176  }
   177  
   178  func (r *rleBuffer) Write(p []byte) (n int, err error) {
   179  	var rp *repeatedByte
   180  	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), nil
   187  			}
   188  		}
   189  	}
   190  
   191  	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), nil
   200  }
   201  
   202  func memset(a []byte, b byte) {
   203  	if len(a) == 0 {
   204  		return
   205  	}
   206  	// Double, until we reach power of 2 >= len(a), same as bytes.Repeat,
   207  	// but without allocation.
   208  	a[0] = b
   209  	for i, l := 1, len(a); i < l; i *= 2 {
   210  		copy(a[i:], a[:i])
   211  	}
   212  }
   213  
   214  func (r *rleBuffer) ReadAt(p []byte, off int64) (n int, err error) {
   215  	if len(p) == 0 {
   216  		return
   217  	}
   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].off
   224  		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 += repeat
   228  			if n == len(p) {
   229  				return
   230  			}
   231  			skipBytes = 0
   232  		}
   233  	}
   234  	if n != len(p) {
   235  		err = io.ErrUnexpectedEOF
   236  	}
   237  	return
   238  }
   239  
   240  // Just testing the rleBuffer used in the Zip64 test above. Not used by the zip code.
   241  func TestRLEBuffer(t *testing.T) {
   242  	b := new(rleBuffer)
   243  	var all []byte
   244  	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  	}
   252  
   253  	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  }
   266  
   267  // fakeHash32 is a dummy Hash32 that always returns 0.
   268  type fakeHash32 struct {
   269  	hash.Hash32
   270  }
   271  
   272  func (fakeHash32) Write(p []byte) (int, error) { return len(p), nil }
   273  func (fakeHash32) Sum32() uint32               { return 0 }
   274  
   275  func 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" part
   281  	buf := testZip64(t, size)
   282  	testZip64DirectoryRecordLength(buf, t)
   283  }
   284  
   285  func 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 though
   292  	// 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" part
   296  	buf := testZip64(t, size)
   297  	testZip64DirectoryRecordLength(buf, t)
   298  }
   299  
   300  // Tests that we generate a zip64 file if the directory at offset
   301  // 0xFFFFFFFF, but not before.
   302  func 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)) - dataDescriptorLen
   324  			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  }
   345  
   346  // At 16k records, we need to generate a zip64 file.
   347  func 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  }
   383  
   384  // suffixSaver is an io.Writer & io.ReaderAt that remembers the last 0
   385  // to 'keep' bytes of data written to it. Call Suffix to get the
   386  // suffix bytes.
   387  type suffixSaver struct {
   388  	keep  int
   389  	buf   []byte
   390  	start int
   391  	size  int64
   392  }
   393  
   394  func (ss *suffixSaver) Size() int64 { return ss.size }
   395  
   396  var errDiscardedBytes = errors.New("ReadAt of discarded bytes")
   397  
   398  func (ss *suffixSaver) ReadAt(p []byte, off int64) (n int, err error) {
   399  	back := ss.size - off
   400  	if back > int64(ss.keep) {
   401  		return 0, errDiscardedBytes
   402  	}
   403  	suf := ss.Suffix()
   404  	n = copy(p, suf[len(suf)-int(back):])
   405  	if n != len(p) {
   406  		err = io.EOF
   407  	}
   408  	return
   409  }
   410  
   411  func (ss *suffixSaver) Suffix() []byte {
   412  	if len(ss.buf) < ss.keep {
   413  		return ss.buf
   414  	}
   415  	buf := make([]byte, ss.keep)
   416  	n := copy(buf, ss.buf[ss.start:])
   417  	copy(buf[n:], ss.buf[:])
   418  	return buf
   419  }
   420  
   421  func (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 = space
   429  		}
   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 += n
   437  		if ss.start == ss.keep {
   438  			ss.start = 0
   439  		}
   440  	}
   441  	return
   442  }
   443  
   444  // generatesZip64 reports whether f wrote a zip64 file.
   445  // f is also responsible for closing w.
   446  func 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  }
   452  
   453  type sizedReaderAt interface {
   454  	io.ReaderAt
   455  	Size() int64
   456  }
   457  
   458  func 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  	}
   463  
   464  	sigOff := findSignatureInBlock(d)
   465  	if sigOff == -1 {
   466  		t.Errorf("failed to find signature in block")
   467  		return false
   468  	}
   469  
   470  	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 false
   476  	}
   477  
   478  	d = make([]byte, directory64EndLen)
   479  	if _, err := zip.ReadAt(d, dirOff); err != nil {
   480  		t.Fatalf("ReadAt(off=%d): %v", dirOff, err)
   481  	}
   482  
   483  	b := readBuf(d)
   484  	if sig := b.uint32(); sig != directory64EndSignature {
   485  		return false
   486  	}
   487  
   488  	size := b.uint64()
   489  	if size != directory64EndLen-12 {
   490  		t.Errorf("expected length of %d, got %d", directory64EndLen-12, size)
   491  	}
   492  	return true
   493  }
   494  
   495  // Zip64 is required if the total size of the records is uint32max.
   496  func 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 bytes
   508  	// 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  			}
   516  
   517  			uint16string := strings.Repeat(".", uint16max)
   518  			remain := wantLen
   519  			for remain > 0 {
   520  				commentLen := int(uint16max) - directoryHeaderLen - 1
   521  				thisRecLen := directoryHeaderLen + int(uint16max) + commentLen
   522  				if int64(thisRecLen) > remain {
   523  					remove := thisRecLen - int(remain)
   524  					commentLen -= remove
   525  					thisRecLen -= remove
   526  				}
   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 EOCD
   564  		// 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  }
   570  
   571  func testZip64(t testing.TB, size int64) *rleBuffer {
   572  	const chunkSize = 1024
   573  	chunks := int(size / chunkSize)
   574  	// write size bytes plus "END\n" to a zip file
   575  	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  	}
   609  
   610  	// read back zip file and check that we get to the end of it
   611  	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  	}
   649  
   650  	if got, want := f0.UncompressedSize64, uint64(size)+uint64(len(end)); got != want {
   651  		t.Errorf("UncompressedSize64 %#x, want %#x", got, want)
   652  	}
   653  
   654  	return buf
   655  }
   656  
   657  // Issue 9857
   658  func testZip64DirectoryRecordLength(buf *rleBuffer, t *testing.T) {
   659  	if !suffixIsZip64(t, buf) {
   660  		t.Fatal("not a zip64")
   661  	}
   662  }
   663  
   664  func testValidHeader(h *FileHeader, t *testing.T) {
   665  	var buf bytes.Buffer
   666  	z := NewWriter(&buf)
   667  
   668  	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  	}
   678  
   679  	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].FileHeader
   685  	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  }
   689  
   690  // Issue 4302.
   691  func TestHeaderInvalidTagAndSize(t *testing.T) {
   692  	const timeFormat = "20060102T150405.000.txt"
   693  
   694  	ts := time.Now()
   695  	filename := ts.Format(timeFormat)
   696  
   697  	h := FileHeader{
   698  		Name:   filename,
   699  		Method: Deflate,
   700  		Extra:  []byte(ts.Format(time.RFC3339Nano)), // missing tag and len, but Extra is best-effort parsing
   701  	}
   702  	h.SetModTime(ts)
   703  
   704  	testValidHeader(&h, t)
   705  }
   706  
   707  func 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 parsing
   712  	}
   713  	testValidHeader(&h, t)
   714  }
   715  
   716  func TestHeaderTooLongErr(t *testing.T) {
   717  	var headerTests = []struct {
   718  		name    string
   719  		extra   []byte
   720  		wanterr error
   721  	}{
   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  	}
   733  
   734  	// write a zip file
   735  	buf := new(bytes.Buffer)
   736  	w := NewWriter(buf)
   737  
   738  	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  	}
   748  
   749  	if err := w.Close(); err != nil {
   750  		t.Fatal(err)
   751  	}
   752  }
   753  
   754  func 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 consulted
   759  	}
   760  	testValidHeader(&h, t)
   761  }
   762  
   763  // Issue 4393. It is valid to have an extra data header
   764  // which contains no body.
   765  func 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 5
   771  			85, 120, 0, 0, // tag 30805 size 0
   772  		},
   773  	}
   774  	testValidHeader(&h, t)
   775  }
   776  
   777  // Just benchmarking how fast the Zip64 test above is. Not related to
   778  // our zip performance, since the test above disabled CRC32 and flate.
   779  func BenchmarkZip64Test(b *testing.B) {
   780  	for i := 0; i < b.N; i++ {
   781  		testZip64(b, 1<<26)
   782  	}
   783  }
   784  
   785  func 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  }
   796  
   797  func TestSuffixSaver(t *testing.T) {
   798  	const keep = 10
   799  	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  				continue
   821  			}
   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  	}
   829  
   830  }
   831  
   832  type zeros struct{}
   833  
   834  func (zeros) Read(p []byte) (int, error) {
   835  	clear(p)
   836  	return len(p), nil
   837  }
   838  

View as plain text