Black Lives Matter. Support the Equal Justice Initiative.

Source file src/archive/zip/zip_test.go

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

View as plain text