Source file src/github.com/klauspost/compress/zip/zip_test.go

Documentation: github.com/klauspost/compress/zip

     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  	"errors"
    12  	"fmt"
    13  	"hash"
    14  	"io"
    15  	"runtime"
    16  	"sort"
    17  	"strings"
    18  	"testing"
    19  	"time"
    20  )
    21  
    22  func TestOver65kFiles(t *testing.T) {
    23  	if testing.Short() {
    24  		t.Skip("skipping in short mode")
    25  	}
    26  	buf := new(bytes.Buffer)
    27  	w := NewWriter(buf)
    28  	const nFiles = (1 << 16) + 42
    29  	for i := 0; i < nFiles; i++ {
    30  		_, err := w.CreateHeader(&FileHeader{
    31  			Name:   fmt.Sprintf("%d.dat", i),
    32  			Method: Store, // avoid Issue 6136 and Issue 6138
    33  		})
    34  		if err != nil {
    35  			t.Fatalf("creating file %d: %v", i, err)
    36  		}
    37  	}
    38  	if err := w.Close(); err != nil {
    39  		t.Fatalf("Writer.Close: %v", err)
    40  	}
    41  	s := buf.String()
    42  	zr, err := NewReader(strings.NewReader(s), int64(len(s)))
    43  	if err != nil {
    44  		t.Fatalf("NewReader: %v", err)
    45  	}
    46  	if got := len(zr.File); got != nFiles {
    47  		t.Fatalf("File contains %d files, want %d", got, nFiles)
    48  	}
    49  	for i := 0; i < nFiles; i++ {
    50  		want := fmt.Sprintf("%d.dat", i)
    51  		if zr.File[i].Name != want {
    52  			t.Fatalf("File(%d) = %q, want %q", i, zr.File[i].Name, want)
    53  		}
    54  	}
    55  }
    56  
    57  func TestModTime(t *testing.T) {
    58  	var testTime = time.Date(2009, time.November, 10, 23, 45, 58, 0, time.UTC)
    59  	fh := new(FileHeader)
    60  	fh.SetModTime(testTime)
    61  	outTime := fh.ModTime()
    62  	if !outTime.Equal(testTime) {
    63  		t.Errorf("times don't match: got %s, want %s", outTime, testTime)
    64  	}
    65  }
    66  
    67  func testHeaderRoundTrip(fh *FileHeader, wantUncompressedSize uint32, wantUncompressedSize64 uint64, t *testing.T) {
    68  	fi := fh.FileInfo()
    69  	fh2, err := FileInfoHeader(fi)
    70  	if err != nil {
    71  		t.Fatal(err)
    72  	}
    73  	if got, want := fh2.Name, fh.Name; got != want {
    74  		t.Errorf("Name: got %s, want %s\n", got, want)
    75  	}
    76  	if got, want := fh2.UncompressedSize, wantUncompressedSize; got != want {
    77  		t.Errorf("UncompressedSize: got %d, want %d\n", got, want)
    78  	}
    79  	if got, want := fh2.UncompressedSize64, wantUncompressedSize64; got != want {
    80  		t.Errorf("UncompressedSize64: got %d, want %d\n", got, want)
    81  	}
    82  	if got, want := fh2.ModifiedTime, fh.ModifiedTime; got != want {
    83  		t.Errorf("ModifiedTime: got %d, want %d\n", got, want)
    84  	}
    85  	if got, want := fh2.ModifiedDate, fh.ModifiedDate; got != want {
    86  		t.Errorf("ModifiedDate: got %d, want %d\n", got, want)
    87  	}
    88  
    89  	if sysfh, ok := fi.Sys().(*FileHeader); !ok && sysfh != fh {
    90  		t.Errorf("Sys didn't return original *FileHeader")
    91  	}
    92  }
    93  
    94  func TestFileHeaderRoundTrip(t *testing.T) {
    95  	fh := &FileHeader{
    96  		Name:             "foo.txt",
    97  		UncompressedSize: 987654321,
    98  		ModifiedTime:     1234,
    99  		ModifiedDate:     5678,
   100  	}
   101  	testHeaderRoundTrip(fh, fh.UncompressedSize, uint64(fh.UncompressedSize), t)
   102  }
   103  
   104  func TestFileHeaderRoundTrip64(t *testing.T) {
   105  	fh := &FileHeader{
   106  		Name:               "foo.txt",
   107  		UncompressedSize64: 9876543210,
   108  		ModifiedTime:       1234,
   109  		ModifiedDate:       5678,
   110  	}
   111  	testHeaderRoundTrip(fh, uint32max, fh.UncompressedSize64, t)
   112  }
   113  
   114  func TestFileHeaderRoundTripModified(t *testing.T) {
   115  	fh := &FileHeader{
   116  		Name:             "foo.txt",
   117  		UncompressedSize: 987654321,
   118  		Modified:         time.Now().Local(),
   119  		ModifiedTime:     1234,
   120  		ModifiedDate:     5678,
   121  	}
   122  	fi := fh.FileInfo()
   123  	fh2, err := FileInfoHeader(fi)
   124  	if err != nil {
   125  		t.Fatal(err)
   126  	}
   127  	if got, want := fh2.Modified, fh.Modified.UTC(); got != want {
   128  		t.Errorf("Modified: got %s, want %s\n", got, want)
   129  	}
   130  	if got, want := fi.ModTime(), fh.Modified.UTC(); got != want {
   131  		t.Errorf("Modified: got %s, want %s\n", got, want)
   132  	}
   133  }
   134  
   135  func TestFileHeaderRoundTripWithoutModified(t *testing.T) {
   136  	fh := &FileHeader{
   137  		Name:             "foo.txt",
   138  		UncompressedSize: 987654321,
   139  		ModifiedTime:     1234,
   140  		ModifiedDate:     5678,
   141  	}
   142  	fi := fh.FileInfo()
   143  	fh2, err := FileInfoHeader(fi)
   144  	if err != nil {
   145  		t.Fatal(err)
   146  	}
   147  	if got, want := fh2.ModTime(), fh.ModTime(); got != want {
   148  		t.Errorf("Modified: got %s, want %s\n", got, want)
   149  	}
   150  	if got, want := fi.ModTime(), fh.ModTime(); got != want {
   151  		t.Errorf("Modified: got %s, want %s\n", got, want)
   152  	}
   153  }
   154  
   155  type repeatedByte struct {
   156  	off int64
   157  	b   byte
   158  	n   int64
   159  }
   160  
   161  // rleBuffer is a run-length-encoded byte buffer.
   162  // It's an io.Writer (like a bytes.Buffer) and also an io.ReaderAt,
   163  // allowing random-access reads.
   164  type rleBuffer struct {
   165  	buf []repeatedByte
   166  }
   167  
   168  func (r *rleBuffer) Size() int64 {
   169  	if len(r.buf) == 0 {
   170  		return 0
   171  	}
   172  	last := &r.buf[len(r.buf)-1]
   173  	return last.off + last.n
   174  }
   175  
   176  func (r *rleBuffer) Write(p []byte) (n int, err error) {
   177  	var rp *repeatedByte
   178  	if len(r.buf) > 0 {
   179  		rp = &r.buf[len(r.buf)-1]
   180  		// Fast path, if p is entirely the same byte repeated.
   181  		if lastByte := rp.b; len(p) > 0 && p[0] == lastByte {
   182  			if bytes.Count(p, []byte{lastByte}) == len(p) {
   183  				rp.n += int64(len(p))
   184  				return len(p), nil
   185  			}
   186  		}
   187  	}
   188  
   189  	for _, b := range p {
   190  		if rp == nil || rp.b != b {
   191  			r.buf = append(r.buf, repeatedByte{r.Size(), b, 1})
   192  			rp = &r.buf[len(r.buf)-1]
   193  		} else {
   194  			rp.n++
   195  		}
   196  	}
   197  	return len(p), nil
   198  }
   199  
   200  func min(x, y int64) int64 {
   201  	if x < y {
   202  		return x
   203  	}
   204  	return y
   205  }
   206  
   207  func memset(a []byte, b byte) {
   208  	if len(a) == 0 {
   209  		return
   210  	}
   211  	// Double, until we reach power of 2 >= len(a), same as bytes.Repeat,
   212  	// but without allocation.
   213  	a[0] = b
   214  	for i, l := 1, len(a); i < l; i *= 2 {
   215  		copy(a[i:], a[:i])
   216  	}
   217  }
   218  
   219  func (r *rleBuffer) ReadAt(p []byte, off int64) (n int, err error) {
   220  	if len(p) == 0 {
   221  		return
   222  	}
   223  	skipParts := sort.Search(len(r.buf), func(i int) bool {
   224  		part := &r.buf[i]
   225  		return part.off+part.n > off
   226  	})
   227  	parts := r.buf[skipParts:]
   228  	if len(parts) > 0 {
   229  		skipBytes := off - parts[0].off
   230  		for _, part := range parts {
   231  			repeat := int(min(part.n-skipBytes, int64(len(p)-n)))
   232  			memset(p[n:n+repeat], part.b)
   233  			n += repeat
   234  			if n == len(p) {
   235  				return
   236  			}
   237  			skipBytes = 0
   238  		}
   239  	}
   240  	if n != len(p) {
   241  		err = io.ErrUnexpectedEOF
   242  	}
   243  	return
   244  }
   245  
   246  // Just testing the rleBuffer used in the Zip64 test above. Not used by the zip code.
   247  func TestRLEBuffer(t *testing.T) {
   248  	b := new(rleBuffer)
   249  	var all []byte
   250  	writes := []string{"abcdeee", "eeeeeee", "eeeefghaaiii"}
   251  	for _, w := range writes {
   252  		b.Write([]byte(w))
   253  		all = append(all, w...)
   254  	}
   255  	if len(b.buf) != 10 {
   256  		t.Fatalf("len(b.buf) = %d; want 10", len(b.buf))
   257  	}
   258  
   259  	for i := 0; i < len(all); i++ {
   260  		for j := 0; j < len(all)-i; j++ {
   261  			buf := make([]byte, j)
   262  			n, err := b.ReadAt(buf, int64(i))
   263  			if err != nil || n != len(buf) {
   264  				t.Errorf("ReadAt(%d, %d) = %d, %v; want %d, nil", i, j, n, err, len(buf))
   265  			}
   266  			if !bytes.Equal(buf, all[i:i+j]) {
   267  				t.Errorf("ReadAt(%d, %d) = %q; want %q", i, j, buf, all[i:i+j])
   268  			}
   269  		}
   270  	}
   271  }
   272  
   273  // fakeHash32 is a dummy Hash32 that always returns 0.
   274  type fakeHash32 struct {
   275  	hash.Hash32
   276  }
   277  
   278  func (fakeHash32) Write(p []byte) (int, error) { return len(p), nil }
   279  func (fakeHash32) Sum32() uint32               { return 0 }
   280  
   281  func TestZip64(t *testing.T) {
   282  	if testing.Short() {
   283  		t.Skip("slow test; skipping")
   284  	}
   285  	t.Parallel()
   286  	const size = 1 << 32 // before the "END\n" part
   287  	buf := testZip64(t, size)
   288  	testZip64DirectoryRecordLength(buf, t)
   289  }
   290  
   291  func TestZip64EdgeCase(t *testing.T) {
   292  	if testing.Short() {
   293  		t.Skip("slow test; skipping")
   294  	}
   295  	t.Parallel()
   296  	// Test a zip file with uncompressed size 0xFFFFFFFF.
   297  	// That's the magic marker for a 64-bit file, so even though
   298  	// it fits in a 32-bit field we must use the 64-bit field.
   299  	// Go 1.5 and earlier got this wrong,
   300  	// writing an invalid zip file.
   301  	const size = 1<<32 - 1 - int64(len("END\n")) // before the "END\n" part
   302  	buf := testZip64(t, size)
   303  	testZip64DirectoryRecordLength(buf, t)
   304  }
   305  
   306  // Tests that we generate a zip64 file if the directory at offset
   307  // 0xFFFFFFFF, but not before.
   308  func TestZip64DirectoryOffset(t *testing.T) {
   309  	if testing.Short() {
   310  		t.Skip("skipping in short mode")
   311  	}
   312  	t.Parallel()
   313  	const filename = "huge.txt"
   314  	gen := func(wantOff uint64) func(*Writer) {
   315  		return func(w *Writer) {
   316  			w.testHookCloseSizeOffset = func(size, off uint64) {
   317  				if off != wantOff {
   318  					t.Errorf("central directory offset = %d (%x); want %d", off, off, wantOff)
   319  				}
   320  			}
   321  			f, err := w.CreateHeader(&FileHeader{
   322  				Name:   filename,
   323  				Method: Store,
   324  			})
   325  			if err != nil {
   326  				t.Fatal(err)
   327  			}
   328  			f.(*fileWriter).crc32 = fakeHash32{}
   329  			size := wantOff - fileHeaderLen - uint64(len(filename)) - dataDescriptorLen
   330  			if _, err := io.CopyN(f, zeros{}, int64(size)); err != nil {
   331  				t.Fatal(err)
   332  			}
   333  			if err := w.Close(); err != nil {
   334  				t.Fatal(err)
   335  			}
   336  		}
   337  	}
   338  	t.Run("uint32max-2_NoZip64", func(t *testing.T) {
   339  		t.Parallel()
   340  		if generatesZip64(t, gen(0xfffffffe)) {
   341  			t.Error("unexpected zip64")
   342  		}
   343  	})
   344  	t.Run("uint32max-1_Zip64", func(t *testing.T) {
   345  		t.Parallel()
   346  		if !generatesZip64(t, gen(0xffffffff)) {
   347  			t.Error("expected zip64")
   348  		}
   349  	})
   350  }
   351  
   352  // At 16k records, we need to generate a zip64 file.
   353  func TestZip64ManyRecords(t *testing.T) {
   354  	if testing.Short() {
   355  		t.Skip("skipping in short mode")
   356  	}
   357  	t.Parallel()
   358  	gen := func(numRec int) func(*Writer) {
   359  		return func(w *Writer) {
   360  			for i := 0; i < numRec; i++ {
   361  				_, err := w.CreateHeader(&FileHeader{
   362  					Name:   "a.txt",
   363  					Method: Store,
   364  				})
   365  				if err != nil {
   366  					t.Fatal(err)
   367  				}
   368  			}
   369  			if err := w.Close(); err != nil {
   370  				t.Fatal(err)
   371  			}
   372  		}
   373  	}
   374  	// 16k-1 records shouldn't make a zip64:
   375  	t.Run("uint16max-1_NoZip64", func(t *testing.T) {
   376  		t.Parallel()
   377  		if generatesZip64(t, gen(0xfffe)) {
   378  			t.Error("unexpected zip64")
   379  		}
   380  	})
   381  	// 16k records should make a zip64:
   382  	t.Run("uint16max_Zip64", func(t *testing.T) {
   383  		t.Parallel()
   384  		if !generatesZip64(t, gen(0xffff)) {
   385  			t.Error("expected zip64")
   386  		}
   387  	})
   388  }
   389  
   390  // suffixSaver is an io.Writer & io.ReaderAt that remembers the last 0
   391  // to 'keep' bytes of data written to it. Call Suffix to get the
   392  // suffix bytes.
   393  type suffixSaver struct {
   394  	keep  int
   395  	buf   []byte
   396  	start int
   397  	size  int64
   398  }
   399  
   400  func (ss *suffixSaver) Size() int64 { return ss.size }
   401  
   402  var errDiscardedBytes = errors.New("ReadAt of discarded bytes")
   403  
   404  func (ss *suffixSaver) ReadAt(p []byte, off int64) (n int, err error) {
   405  	back := ss.size - off
   406  	if back > int64(ss.keep) {
   407  		return 0, errDiscardedBytes
   408  	}
   409  	suf := ss.Suffix()
   410  	n = copy(p, suf[len(suf)-int(back):])
   411  	if n != len(p) {
   412  		err = io.EOF
   413  	}
   414  	return
   415  }
   416  
   417  func (ss *suffixSaver) Suffix() []byte {
   418  	if len(ss.buf) < ss.keep {
   419  		return ss.buf
   420  	}
   421  	buf := make([]byte, ss.keep)
   422  	n := copy(buf, ss.buf[ss.start:])
   423  	copy(buf[n:], ss.buf[:])
   424  	return buf
   425  }
   426  
   427  func (ss *suffixSaver) Write(p []byte) (n int, err error) {
   428  	n = len(p)
   429  	ss.size += int64(len(p))
   430  	if len(ss.buf) < ss.keep {
   431  		space := ss.keep - len(ss.buf)
   432  		add := len(p)
   433  		if add > space {
   434  			add = space
   435  		}
   436  		ss.buf = append(ss.buf, p[:add]...)
   437  		p = p[add:]
   438  	}
   439  	for len(p) > 0 {
   440  		n := copy(ss.buf[ss.start:], p)
   441  		p = p[n:]
   442  		ss.start += n
   443  		if ss.start == ss.keep {
   444  			ss.start = 0
   445  		}
   446  	}
   447  	return
   448  }
   449  
   450  // generatesZip64 reports whether f wrote a zip64 file.
   451  // f is also responsible for closing w.
   452  func generatesZip64(t *testing.T, f func(w *Writer)) bool {
   453  	ss := &suffixSaver{keep: 10 << 20}
   454  	w := NewWriter(ss)
   455  	f(w)
   456  	return suffixIsZip64(t, ss)
   457  }
   458  
   459  type sizedReaderAt interface {
   460  	io.ReaderAt
   461  	Size() int64
   462  }
   463  
   464  func suffixIsZip64(t *testing.T, zip sizedReaderAt) bool {
   465  	d := make([]byte, 1024)
   466  	if _, err := zip.ReadAt(d, zip.Size()-int64(len(d))); err != nil {
   467  		t.Fatalf("ReadAt: %v", err)
   468  	}
   469  
   470  	sigOff := findSignatureInBlock(d)
   471  	if sigOff == -1 {
   472  		t.Errorf("failed to find signature in block")
   473  		return false
   474  	}
   475  
   476  	dirOff, err := findDirectory64End(zip, zip.Size()-int64(len(d))+int64(sigOff))
   477  	if err != nil {
   478  		t.Fatalf("findDirectory64End: %v", err)
   479  	}
   480  	if dirOff == -1 {
   481  		return false
   482  	}
   483  
   484  	d = make([]byte, directory64EndLen)
   485  	if _, err := zip.ReadAt(d, dirOff); err != nil {
   486  		t.Fatalf("ReadAt(off=%d): %v", dirOff, err)
   487  	}
   488  
   489  	b := readBuf(d)
   490  	if sig := b.uint32(); sig != directory64EndSignature {
   491  		return false
   492  	}
   493  
   494  	size := b.uint64()
   495  	if size != directory64EndLen-12 {
   496  		t.Errorf("expected length of %d, got %d", directory64EndLen-12, size)
   497  	}
   498  	return true
   499  }
   500  
   501  // Zip64 is required if the total size of the records is uint32max.
   502  func TestZip64LargeDirectory(t *testing.T) {
   503  	if runtime.GOARCH == "wasm" {
   504  		t.Skip("too slow on wasm")
   505  	}
   506  	if testing.Short() {
   507  		t.Skip("skipping in short mode")
   508  	}
   509  	t.Parallel()
   510  	// gen returns a func that writes a zip with a wantLen bytes
   511  	// of central directory.
   512  	gen := func(wantLen int64) func(*Writer) {
   513  		return func(w *Writer) {
   514  			w.testHookCloseSizeOffset = func(size, off uint64) {
   515  				if size != uint64(wantLen) {
   516  					t.Errorf("Close central directory size = %d; want %d", size, wantLen)
   517  				}
   518  			}
   519  
   520  			uint16string := strings.Repeat(".", uint16max)
   521  			remain := wantLen
   522  			for remain > 0 {
   523  				commentLen := int(uint16max) - directoryHeaderLen - 1
   524  				thisRecLen := directoryHeaderLen + int(uint16max) + commentLen
   525  				if int64(thisRecLen) > remain {
   526  					remove := thisRecLen - int(remain)
   527  					commentLen -= remove
   528  					thisRecLen -= remove
   529  				}
   530  				remain -= int64(thisRecLen)
   531  				f, err := w.CreateHeader(&FileHeader{
   532  					Name:    uint16string,
   533  					Comment: uint16string[:commentLen],
   534  				})
   535  				if err != nil {
   536  					t.Fatalf("CreateHeader: %v", err)
   537  				}
   538  				f.(*fileWriter).crc32 = fakeHash32{}
   539  			}
   540  			if err := w.Close(); err != nil {
   541  				t.Fatalf("Close: %v", err)
   542  			}
   543  		}
   544  	}
   545  	t.Run("uint32max-1_NoZip64", func(t *testing.T) {
   546  		t.Parallel()
   547  		if generatesZip64(t, gen(uint32max-1)) {
   548  			t.Error("unexpected zip64")
   549  		}
   550  	})
   551  	t.Run("uint32max_HasZip64", func(t *testing.T) {
   552  		t.Parallel()
   553  		if !generatesZip64(t, gen(uint32max)) {
   554  			t.Error("expected zip64")
   555  		}
   556  	})
   557  }
   558  
   559  func testZip64(t testing.TB, size int64) *rleBuffer {
   560  	const chunkSize = 1024
   561  	chunks := int(size / chunkSize)
   562  	// write size bytes plus "END\n" to a zip file
   563  	buf := new(rleBuffer)
   564  	w := NewWriter(buf)
   565  	f, err := w.CreateHeader(&FileHeader{
   566  		Name:   "huge.txt",
   567  		Method: Store,
   568  	})
   569  	if err != nil {
   570  		t.Fatal(err)
   571  	}
   572  	f.(*fileWriter).crc32 = fakeHash32{}
   573  	chunk := make([]byte, chunkSize)
   574  	for i := range chunk {
   575  		chunk[i] = '.'
   576  	}
   577  	for i := 0; i < chunks; i++ {
   578  		_, err := f.Write(chunk)
   579  		if err != nil {
   580  			t.Fatal("write chunk:", err)
   581  		}
   582  	}
   583  	if frag := int(size % chunkSize); frag > 0 {
   584  		_, err := f.Write(chunk[:frag])
   585  		if err != nil {
   586  			t.Fatal("write chunk:", err)
   587  		}
   588  	}
   589  	end := []byte("END\n")
   590  	_, err = f.Write(end)
   591  	if err != nil {
   592  		t.Fatal("write end:", err)
   593  	}
   594  	if err := w.Close(); err != nil {
   595  		t.Fatal(err)
   596  	}
   597  
   598  	// read back zip file and check that we get to the end of it
   599  	r, err := NewReader(buf, int64(buf.Size()))
   600  	if err != nil {
   601  		t.Fatal("reader:", err)
   602  	}
   603  	f0 := r.File[0]
   604  	rc, err := f0.Open()
   605  	if err != nil {
   606  		t.Fatal("opening:", err)
   607  	}
   608  	rc.(*checksumReader).hash = fakeHash32{}
   609  	for i := 0; i < chunks; i++ {
   610  		_, err := io.ReadFull(rc, chunk)
   611  		if err != nil {
   612  			t.Fatal("read:", err)
   613  		}
   614  	}
   615  	if frag := int(size % chunkSize); frag > 0 {
   616  		_, err := io.ReadFull(rc, chunk[:frag])
   617  		if err != nil {
   618  			t.Fatal("read:", err)
   619  		}
   620  	}
   621  	gotEnd, err := io.ReadAll(rc)
   622  	if err != nil {
   623  		t.Fatal("read end:", err)
   624  	}
   625  	if !bytes.Equal(gotEnd, end) {
   626  		t.Errorf("End of zip64 archive %q, want %q", gotEnd, end)
   627  	}
   628  	err = rc.Close()
   629  	if err != nil {
   630  		t.Fatal("closing:", err)
   631  	}
   632  	if size+int64(len("END\n")) >= 1<<32-1 {
   633  		if got, want := f0.UncompressedSize, uint32(uint32max); got != want {
   634  			t.Errorf("UncompressedSize %#x, want %#x", got, want)
   635  		}
   636  	}
   637  
   638  	if got, want := f0.UncompressedSize64, uint64(size)+uint64(len(end)); got != want {
   639  		t.Errorf("UncompressedSize64 %#x, want %#x", got, want)
   640  	}
   641  
   642  	return buf
   643  }
   644  
   645  // Issue 9857
   646  func testZip64DirectoryRecordLength(buf *rleBuffer, t *testing.T) {
   647  	if !suffixIsZip64(t, buf) {
   648  		t.Fatal("not a zip64")
   649  	}
   650  }
   651  
   652  func testValidHeader(h *FileHeader, t *testing.T) {
   653  	var buf bytes.Buffer
   654  	z := NewWriter(&buf)
   655  
   656  	f, err := z.CreateHeader(h)
   657  	if err != nil {
   658  		t.Fatalf("error creating header: %v", err)
   659  	}
   660  	if _, err := f.Write([]byte("hi")); err != nil {
   661  		t.Fatalf("error writing content: %v", err)
   662  	}
   663  	if err := z.Close(); err != nil {
   664  		t.Fatalf("error closing zip writer: %v", err)
   665  	}
   666  
   667  	b := buf.Bytes()
   668  	zf, err := NewReader(bytes.NewReader(b), int64(len(b)))
   669  	if err != nil {
   670  		t.Fatalf("got %v, expected nil", err)
   671  	}
   672  	zh := zf.File[0].FileHeader
   673  	if zh.Name != h.Name || zh.Method != h.Method || zh.UncompressedSize64 != uint64(len("hi")) {
   674  		t.Fatalf("got %q/%d/%d expected %q/%d/%d", zh.Name, zh.Method, zh.UncompressedSize64, h.Name, h.Method, len("hi"))
   675  	}
   676  }
   677  
   678  // Issue 4302.
   679  func TestHeaderInvalidTagAndSize(t *testing.T) {
   680  	const timeFormat = "20060102T150405.000.txt"
   681  
   682  	ts := time.Now()
   683  	filename := ts.Format(timeFormat)
   684  
   685  	h := FileHeader{
   686  		Name:   filename,
   687  		Method: Deflate,
   688  		Extra:  []byte(ts.Format(time.RFC3339Nano)), // missing tag and len, but Extra is best-effort parsing
   689  	}
   690  	h.SetModTime(ts)
   691  
   692  	testValidHeader(&h, t)
   693  }
   694  
   695  func TestHeaderTooShort(t *testing.T) {
   696  	h := FileHeader{
   697  		Name:   "foo.txt",
   698  		Method: Deflate,
   699  		Extra:  []byte{zip64ExtraID}, // missing size and second half of tag, but Extra is best-effort parsing
   700  	}
   701  	testValidHeader(&h, t)
   702  }
   703  
   704  func TestHeaderTooLongErr(t *testing.T) {
   705  	var headerTests = []struct {
   706  		name    string
   707  		extra   []byte
   708  		wanterr error
   709  	}{
   710  		{
   711  			name:    strings.Repeat("x", 1<<16),
   712  			extra:   []byte{},
   713  			wanterr: errLongName,
   714  		},
   715  		{
   716  			name:    "long_extra",
   717  			extra:   bytes.Repeat([]byte{0xff}, 1<<16),
   718  			wanterr: errLongExtra,
   719  		},
   720  	}
   721  
   722  	// write a zip file
   723  	buf := new(bytes.Buffer)
   724  	w := NewWriter(buf)
   725  
   726  	for _, test := range headerTests {
   727  		h := &FileHeader{
   728  			Name:  test.name,
   729  			Extra: test.extra,
   730  		}
   731  		_, err := w.CreateHeader(h)
   732  		if err != test.wanterr {
   733  			t.Errorf("error=%v, want %v", err, test.wanterr)
   734  		}
   735  	}
   736  
   737  	if err := w.Close(); err != nil {
   738  		t.Fatal(err)
   739  	}
   740  }
   741  
   742  func TestHeaderIgnoredSize(t *testing.T) {
   743  	h := FileHeader{
   744  		Name:   "foo.txt",
   745  		Method: Deflate,
   746  		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
   747  	}
   748  	testValidHeader(&h, t)
   749  }
   750  
   751  // Issue 4393. It is valid to have an extra data header
   752  // which contains no body.
   753  func TestZeroLengthHeader(t *testing.T) {
   754  	h := FileHeader{
   755  		Name:   "extadata.txt",
   756  		Method: Deflate,
   757  		Extra: []byte{
   758  			85, 84, 5, 0, 3, 154, 144, 195, 77, // tag 21589 size 5
   759  			85, 120, 0, 0, // tag 30805 size 0
   760  		},
   761  	}
   762  	testValidHeader(&h, t)
   763  }
   764  
   765  // Just benchmarking how fast the Zip64 test above is. Not related to
   766  // our zip performance, since the test above disabled CRC32 and flate.
   767  func BenchmarkZip64Test(b *testing.B) {
   768  	for i := 0; i < b.N; i++ {
   769  		testZip64(b, 1<<26)
   770  	}
   771  }
   772  
   773  func BenchmarkZip64TestSizes(b *testing.B) {
   774  	for _, size := range []int64{1 << 12, 1 << 20, 1 << 26} {
   775  		b.Run(fmt.Sprint(size), func(b *testing.B) {
   776  			b.RunParallel(func(pb *testing.PB) {
   777  				for pb.Next() {
   778  					testZip64(b, size)
   779  				}
   780  			})
   781  		})
   782  	}
   783  }
   784  
   785  func TestSuffixSaver(t *testing.T) {
   786  	const keep = 10
   787  	ss := &suffixSaver{keep: keep}
   788  	ss.Write([]byte("abc"))
   789  	if got := string(ss.Suffix()); got != "abc" {
   790  		t.Errorf("got = %q; want abc", got)
   791  	}
   792  	ss.Write([]byte("defghijklmno"))
   793  	if got := string(ss.Suffix()); got != "fghijklmno" {
   794  		t.Errorf("got = %q; want fghijklmno", got)
   795  	}
   796  	if got, want := ss.Size(), int64(len("abc")+len("defghijklmno")); got != want {
   797  		t.Errorf("Size = %d; want %d", got, want)
   798  	}
   799  	buf := make([]byte, ss.Size())
   800  	for off := int64(0); off < ss.Size(); off++ {
   801  		for size := 1; size <= int(ss.Size()-off); size++ {
   802  			readBuf := buf[:size]
   803  			n, err := ss.ReadAt(readBuf, off)
   804  			if off < ss.Size()-keep {
   805  				if err != errDiscardedBytes {
   806  					t.Errorf("off %d, size %d = %v, %v (%q); want errDiscardedBytes", off, size, n, err, readBuf[:n])
   807  				}
   808  				continue
   809  			}
   810  			want := "abcdefghijklmno"[off : off+int64(size)]
   811  			got := string(readBuf[:n])
   812  			if err != nil || got != want {
   813  				t.Errorf("off %d, size %d = %v, %v (%q); want %q", off, size, n, err, got, want)
   814  			}
   815  		}
   816  	}
   817  
   818  }
   819  
   820  type zeros struct{}
   821  
   822  func (zeros) Read(p []byte) (int, error) {
   823  	for i := range p {
   824  		p[i] = 0
   825  	}
   826  	return len(p), nil
   827  }
   828  

View as plain text