// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package zip import ( "bytes" "compress/flate" "encoding/binary" "fmt" "hash/crc32" "io" "io/fs" "math/rand" "os" "strings" "testing" "testing/fstest" "time" ) // TODO(adg): a more sophisticated test suite type WriteTest struct { Name string Data []byte Method uint16 Mode fs.FileMode } var writeTests = []WriteTest{ { Name: "foo", Data: []byte("Rabbits, guinea pigs, gophers, marsupial rats, and quolls."), Method: Store, Mode: 0666, }, { Name: "bar", Data: nil, // large data set in the test Method: Deflate, Mode: 0644, }, { Name: "setuid", Data: []byte("setuid file"), Method: Deflate, Mode: 0755 | fs.ModeSetuid, }, { Name: "setgid", Data: []byte("setgid file"), Method: Deflate, Mode: 0755 | fs.ModeSetgid, }, { Name: "symlink", Data: []byte("../link/target"), Method: Deflate, Mode: 0755 | fs.ModeSymlink, }, { Name: "device", Data: []byte("device file"), Method: Deflate, Mode: 0755 | fs.ModeDevice, }, { Name: "chardevice", Data: []byte("char device file"), Method: Deflate, Mode: 0755 | fs.ModeDevice | fs.ModeCharDevice, }, } func TestWriter(t *testing.T) { largeData := make([]byte, 1<<17) if _, err := rand.Read(largeData); err != nil { t.Fatal("rand.Read failed:", err) } writeTests[1].Data = largeData defer func() { writeTests[1].Data = nil }() // write a zip file buf := new(bytes.Buffer) w := NewWriter(buf) for _, wt := range writeTests { testCreate(t, w, &wt) } if err := w.Close(); err != nil { t.Fatal(err) } // read it back r, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { t.Fatal(err) } for i, wt := range writeTests { testReadFile(t, r.File[i], &wt) } } // TestWriterComment is test for EOCD comment read/write. func TestWriterComment(t *testing.T) { var tests = []struct { comment string ok bool }{ {"hi, hello", true}, {"hi, こんにちわ", true}, {strings.Repeat("a", uint16max), true}, {strings.Repeat("a", uint16max+1), false}, } for _, test := range tests { // write a zip file buf := new(bytes.Buffer) w := NewWriter(buf) if err := w.SetComment(test.comment); err != nil { if test.ok { t.Fatalf("SetComment: unexpected error %v", err) } continue } else { if !test.ok { t.Fatalf("SetComment: unexpected success, want error") } } if err := w.Close(); test.ok == (err != nil) { t.Fatal(err) } if w.closed != test.ok { t.Fatalf("Writer.closed: got %v, want %v", w.closed, test.ok) } // skip read test in failure cases if !test.ok { continue } // read it back r, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { t.Fatal(err) } if r.Comment != test.comment { t.Fatalf("Reader.Comment: got %v, want %v", r.Comment, test.comment) } } } func TestWriterUTF8(t *testing.T) { var utf8Tests = []struct { name string comment string nonUTF8 bool flags uint16 }{ { name: "hi, hello", comment: "in the world", flags: 0x8, }, { name: "hi, こんにちわ", comment: "in the world", flags: 0x808, }, { name: "hi, こんにちわ", comment: "in the world", nonUTF8: true, flags: 0x8, }, { name: "hi, hello", comment: "in the 世界", flags: 0x808, }, { name: "hi, こんにちわ", comment: "in the 世界", flags: 0x808, }, { name: "the replacement rune is �", comment: "the replacement rune is �", flags: 0x808, }, { // Name is Japanese encoded in Shift JIS. name: "\x93\xfa\x96{\x8c\xea.txt", comment: "in the 世界", flags: 0x008, // UTF-8 must not be set }, } // write a zip file buf := new(bytes.Buffer) w := NewWriter(buf) for _, test := range utf8Tests { h := &FileHeader{ Name: test.name, Comment: test.comment, NonUTF8: test.nonUTF8, Method: Deflate, } w, err := w.CreateHeader(h) if err != nil { t.Fatal(err) } w.Write([]byte{}) } if err := w.Close(); err != nil { t.Fatal(err) } // read it back r, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { t.Fatal(err) } for i, test := range utf8Tests { flags := r.File[i].Flags if flags != test.flags { t.Errorf("CreateHeader(name=%q comment=%q nonUTF8=%v): flags=%#x, want %#x", test.name, test.comment, test.nonUTF8, flags, test.flags) } } } func TestWriterTime(t *testing.T) { var buf bytes.Buffer h := &FileHeader{ Name: "test.txt", Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)), } w := NewWriter(&buf) if _, err := w.CreateHeader(h); err != nil { t.Fatalf("unexpected CreateHeader error: %v", err) } if err := w.Close(); err != nil { t.Fatalf("unexpected Close error: %v", err) } want, err := os.ReadFile("testdata/time-go.zip") if err != nil { t.Fatalf("unexpected ReadFile error: %v", err) } if got := buf.Bytes(); !bytes.Equal(got, want) { fmt.Printf("%x\n%x\n", got, want) t.Error("contents of time-go.zip differ") } } func TestWriterOffset(t *testing.T) { largeData := make([]byte, 1<<17) if _, err := rand.Read(largeData); err != nil { t.Fatal("rand.Read failed:", err) } writeTests[1].Data = largeData defer func() { writeTests[1].Data = nil }() // write a zip file buf := new(bytes.Buffer) existingData := []byte{1, 2, 3, 1, 2, 3, 1, 2, 3} n, _ := buf.Write(existingData) w := NewWriter(buf) w.SetOffset(int64(n)) for _, wt := range writeTests { testCreate(t, w, &wt) } if err := w.Close(); err != nil { t.Fatal(err) } // read it back r, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { t.Fatal(err) } for i, wt := range writeTests { testReadFile(t, r.File[i], &wt) } } func TestWriterFlush(t *testing.T) { var buf bytes.Buffer w := NewWriter(struct{ io.Writer }{&buf}) _, err := w.Create("foo") if err != nil { t.Fatal(err) } if buf.Len() > 0 { t.Fatalf("Unexpected %d bytes already in buffer", buf.Len()) } if err := w.Flush(); err != nil { t.Fatal(err) } if buf.Len() == 0 { t.Fatal("No bytes written after Flush") } } func TestWriterDir(t *testing.T) { w := NewWriter(io.Discard) dw, err := w.Create("dir/") if err != nil { t.Fatal(err) } if _, err := dw.Write(nil); err != nil { t.Errorf("Write(nil) to directory: got %v, want nil", err) } if _, err := dw.Write([]byte("hello")); err == nil { t.Error(`Write("hello") to directory: got nil error, want non-nil`) } } func TestWriterDirAttributes(t *testing.T) { var buf bytes.Buffer w := NewWriter(&buf) if _, err := w.CreateHeader(&FileHeader{ Name: "dir/", Method: Deflate, CompressedSize64: 1234, UncompressedSize64: 5678, }); err != nil { t.Fatal(err) } if err := w.Close(); err != nil { t.Fatal(err) } b := buf.Bytes() var sig [4]byte binary.LittleEndian.PutUint32(sig[:], uint32(fileHeaderSignature)) idx := bytes.Index(b, sig[:]) if idx == -1 { t.Fatal("file header not found") } b = b[idx:] if !bytes.Equal(b[6:10], []byte{0, 0, 0, 0}) { // FileHeader.Flags: 0, FileHeader.Method: 0 t.Errorf("unexpected method and flags: %v", b[6:10]) } if !bytes.Equal(b[14:26], make([]byte, 12)) { // FileHeader.{CRC32,CompressSize,UncompressedSize} all zero. t.Errorf("unexpected crc, compress and uncompressed size to be 0 was: %v", b[14:26]) } binary.LittleEndian.PutUint32(sig[:], uint32(dataDescriptorSignature)) if bytes.Contains(b, sig[:]) { t.Error("there should be no data descriptor") } } func TestWriterCopy(t *testing.T) { // make a zip file buf := new(bytes.Buffer) w := NewWriter(buf) for _, wt := range writeTests { testCreate(t, w, &wt) } if err := w.Close(); err != nil { t.Fatal(err) } // read it back src, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { t.Fatal(err) } for i, wt := range writeTests { testReadFile(t, src.File[i], &wt) } // make a new zip file copying the old compressed data. buf2 := new(bytes.Buffer) dst := NewWriter(buf2) for _, f := range src.File { if err := dst.Copy(f); err != nil { t.Fatal(err) } } if err := dst.Close(); err != nil { t.Fatal(err) } // read the new one back r, err := NewReader(bytes.NewReader(buf2.Bytes()), int64(buf2.Len())) if err != nil { t.Fatal(err) } for i, wt := range writeTests { testReadFile(t, r.File[i], &wt) } } func TestWriterCreateRaw(t *testing.T) { files := []struct { name string content []byte method uint16 flags uint16 crc32 uint32 uncompressedSize uint64 compressedSize uint64 }{ { name: "small store w desc", content: []byte("gophers"), method: Store, flags: 0x8, }, { name: "small deflate wo desc", content: bytes.Repeat([]byte("abcdefg"), 2048), method: Deflate, }, } // write a zip file archive := new(bytes.Buffer) w := NewWriter(archive) for i := range files { f := &files[i] f.crc32 = crc32.ChecksumIEEE(f.content) size := uint64(len(f.content)) f.uncompressedSize = size f.compressedSize = size var compressedContent []byte if f.method == Deflate { var buf bytes.Buffer w, err := flate.NewWriter(&buf, flate.BestSpeed) if err != nil { t.Fatalf("flate.NewWriter err = %v", err) } _, err = w.Write(f.content) if err != nil { t.Fatalf("flate Write err = %v", err) } err = w.Close() if err != nil { t.Fatalf("flate Writer.Close err = %v", err) } compressedContent = buf.Bytes() f.compressedSize = uint64(len(compressedContent)) } h := &FileHeader{ Name: f.name, Method: f.method, Flags: f.flags, CRC32: f.crc32, CompressedSize64: f.compressedSize, UncompressedSize64: f.uncompressedSize, } w, err := w.CreateRaw(h) if err != nil { t.Fatal(err) } if compressedContent != nil { _, err = w.Write(compressedContent) } else { _, err = w.Write(f.content) } if err != nil { t.Fatalf("%s Write got %v; want nil", f.name, err) } } if err := w.Close(); err != nil { t.Fatal(err) } // read it back r, err := NewReader(bytes.NewReader(archive.Bytes()), int64(archive.Len())) if err != nil { t.Fatal(err) } for i, want := range files { got := r.File[i] if got.Name != want.name { t.Errorf("got Name %s; want %s", got.Name, want.name) } if got.Method != want.method { t.Errorf("%s: got Method %#x; want %#x", want.name, got.Method, want.method) } if got.Flags != want.flags { t.Errorf("%s: got Flags %#x; want %#x", want.name, got.Flags, want.flags) } if got.CRC32 != want.crc32 { t.Errorf("%s: got CRC32 %#x; want %#x", want.name, got.CRC32, want.crc32) } if got.CompressedSize64 != want.compressedSize { t.Errorf("%s: got CompressedSize64 %d; want %d", want.name, got.CompressedSize64, want.compressedSize) } if got.UncompressedSize64 != want.uncompressedSize { t.Errorf("%s: got UncompressedSize64 %d; want %d", want.name, got.UncompressedSize64, want.uncompressedSize) } r, err := got.Open() if err != nil { t.Errorf("%s: Open err = %v", got.Name, err) continue } buf, err := io.ReadAll(r) if err != nil { t.Errorf("%s: ReadAll err = %v", got.Name, err) continue } if !bytes.Equal(buf, want.content) { t.Errorf("%v: ReadAll returned unexpected bytes", got.Name) } } } func testCreate(t *testing.T, w *Writer, wt *WriteTest) { header := &FileHeader{ Name: wt.Name, Method: wt.Method, } if wt.Mode != 0 { header.SetMode(wt.Mode) } f, err := w.CreateHeader(header) if err != nil { t.Fatal(err) } _, err = f.Write(wt.Data) if err != nil { t.Fatal(err) } } func testReadFile(t *testing.T, f *File, wt *WriteTest) { if f.Name != wt.Name { t.Fatalf("File name: got %q, want %q", f.Name, wt.Name) } testFileMode(t, f, wt.Mode) rc, err := f.Open() if err != nil { t.Fatalf("opening %s: %v", f.Name, err) } b, err := io.ReadAll(rc) if err != nil { t.Fatalf("reading %s: %v", f.Name, err) } err = rc.Close() if err != nil { t.Fatalf("closing %s: %v", f.Name, err) } if !bytes.Equal(b, wt.Data) { t.Errorf("File contents %q, want %q", b, wt.Data) } } func BenchmarkCompressedZipGarbage(b *testing.B) { bigBuf := bytes.Repeat([]byte("a"), 1<<20) runOnce := func(buf *bytes.Buffer) { buf.Reset() zw := NewWriter(buf) for j := 0; j < 3; j++ { w, _ := zw.CreateHeader(&FileHeader{ Name: "foo", Method: Deflate, }) w.Write(bigBuf) } zw.Close() } b.ReportAllocs() // Run once and then reset the timer. // This effectively discards the very large initial flate setup cost, // as well as the initialization of bigBuf. runOnce(&bytes.Buffer{}) b.ResetTimer() b.RunParallel(func(pb *testing.PB) { var buf bytes.Buffer for pb.Next() { runOnce(&buf) } }) } func writeTestsToFS(tests []WriteTest) fs.FS { fsys := fstest.MapFS{} for _, wt := range tests { fsys[wt.Name] = &fstest.MapFile{ Data: wt.Data, Mode: wt.Mode, } } return fsys } func TestWriterAddFS(t *testing.T) { buf := new(bytes.Buffer) w := NewWriter(buf) tests := []WriteTest{ { Name: "file.go", Data: []byte("hello"), Mode: 0644, }, { Name: "subfolder/another.go", Data: []byte("world"), Mode: 0644, }, } err := w.AddFS(writeTestsToFS(tests)) if err != nil { t.Fatal(err) } if err := w.Close(); err != nil { t.Fatal(err) } // read it back r, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { t.Fatal(err) } for i, wt := range tests { testReadFile(t, r.File[i], &wt) } } func TestIssue61875(t *testing.T) { buf := new(bytes.Buffer) w := NewWriter(buf) tests := []WriteTest{ { Name: "symlink", Data: []byte("../link/target"), Method: Deflate, Mode: 0755 | fs.ModeSymlink, }, { Name: "device", Data: []byte(""), Method: Deflate, Mode: 0755 | fs.ModeDevice, }, } err := w.AddFS(writeTestsToFS(tests)) if err == nil { t.Errorf("expected error, got nil") } }