libgo/go/archive/zip/reader_test.go

   1 // Copyright 2010 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 package zip
   6
   7 import (
   8         "bytes"
   9         "encoding/binary"
  10         "io"
  11         "io/ioutil"
  12         "os"
  13         "testing"
  14 )
  15
  16 type ZipTest struct {
  17         Name    string
  18         Comment string
  19         File    []ZipTestFile
  20         Error   os.Error // the error that Opening this file should return
  21 }
  22
  23 type ZipTestFile struct {
  24         Name    string
  25         Content []byte // if blank, will attempt to compare against File
  26         File    string // name of file to compare to (relative to testdata/)
  27 }
  28
  29 var tests = []ZipTest{
  30         {
  31                 Name:    "test.zip",
  32                 Comment: "This is a zipfile comment.",
  33                 File: []ZipTestFile{
  34                         {
  35                                 Name:    "test.txt",
  36                                 Content: []byte("This is a test text file.\n"),
  37                         },
  38                         {
  39                                 Name: "gophercolor16x16.png",
  40                                 File: "gophercolor16x16.png",
  41                         },
  42                 },
  43         },
  44         {
  45                 Name: "r.zip",
  46                 File: []ZipTestFile{
  47                         {
  48                                 Name: "r/r.zip",
  49                                 File: "r.zip",
  50                         },
  51                 },
  52         },
  53         {Name: "readme.zip"},
  54         {Name: "readme.notzip", Error: FormatError},
  55 }
  56
  57 func TestReader(t *testing.T) {
  58         for _, zt := range tests {
  59                 readTestZip(t, zt)
  60         }
  61 }
  62
  63 func readTestZip(t *testing.T, zt ZipTest) {
  64         z, err := OpenReader("testdata/" + zt.Name)
  65         if err != zt.Error {
  66                 t.Errorf("error=%v, want %v", err, zt.Error)
  67                 return
  68         }
  69
  70         // bail here if no Files expected to be tested
  71         // (there may actually be files in the zip, but we don't care)
  72         if zt.File == nil {
  73                 return
  74         }
  75
  76         if z.Comment != zt.Comment {
  77                 t.Errorf("%s: comment=%q, want %q", zt.Name, z.Comment, zt.Comment)
  78         }
  79         if len(z.File) != len(zt.File) {
  80                 t.Errorf("%s: file count=%d, want %d", zt.Name, len(z.File), len(zt.File))
  81         }
  82
  83         // test read of each file
  84         for i, ft := range zt.File {
  85                 readTestFile(t, ft, z.File[i])
  86         }
  87
  88         // test simultaneous reads
  89         n := 0
  90         done := make(chan bool)
  91         for i := 0; i < 5; i++ {
  92                 for j, ft := range zt.File {
  93                         go func() {
  94                                 readTestFile(t, ft, z.File[j])
  95                                 done <- true
  96                         }()
  97                         n++
  98                 }
  99         }
 100         for ; n > 0; n-- {
 101                 <-done
 102         }
 103
 104         // test invalid checksum
 105         z.File[0].CRC32++ // invalidate
 106         r, err := z.File[0].Open()
 107         if err != nil {
 108                 t.Error(err)
 109                 return
 110         }
 111         var b bytes.Buffer
 112         _, err = io.Copy(&b, r)
 113         if err != ChecksumError {
 114                 t.Errorf("%s: copy error=%v, want %v", err, ChecksumError)
 115         }
 116 }
 117
 118 func readTestFile(t *testing.T, ft ZipTestFile, f *File) {
 119         if f.Name != ft.Name {
 120                 t.Errorf("name=%q, want %q", f.Name, ft.Name)
 121         }
 122         var b bytes.Buffer
 123         r, err := f.Open()
 124         if err != nil {
 125                 t.Error(err)
 126                 return
 127         }
 128         _, err = io.Copy(&b, r)
 129         if err != nil {
 130                 t.Error(err)
 131                 return
 132         }
 133         r.Close()
 134         var c []byte
 135         if len(ft.Content) != 0 {
 136                 c = ft.Content
 137         } else if c, err = ioutil.ReadFile("testdata/" + ft.File); err != nil {
 138                 t.Error(err)
 139                 return
 140         }
 141         if b.Len() != len(c) {
 142                 t.Errorf("%s: len=%d, want %d", f.Name, b.Len(), len(c))
 143                 return
 144         }
 145         for i, b := range b.Bytes() {
 146                 if b != c[i] {
 147                         t.Errorf("%s: content[%d]=%q want %q", i, b, c[i])
 148                         return
 149                 }
 150         }
 151 }
 152
 153 func TestInvalidFiles(t *testing.T) {
 154         const size = 1024 * 70 // 70kb
 155         b := make([]byte, size)
 156
 157         // zeroes
 158         _, err := NewReader(sliceReaderAt(b), size)
 159         if err != FormatError {
 160                 t.Errorf("zeroes: error=%v, want %v", err, FormatError)
 161         }
 162
 163         // repeated directoryEndSignatures
 164         sig := make([]byte, 4)
 165         binary.LittleEndian.PutUint32(sig, directoryEndSignature)
 166         for i := 0; i < size-4; i += 4 {
 167                 copy(b[i:i+4], sig)
 168         }
 169         _, err = NewReader(sliceReaderAt(b), size)
 170         if err != FormatError {
 171                 t.Errorf("sigs: error=%v, want %v", err, FormatError)
 172         }
 173 }
 174
 175 type sliceReaderAt []byte
 176
 177 func (r sliceReaderAt) ReadAt(b []byte, off int64) (int, os.Error) {
 178         copy(b, r[int(off):int(off)+len(b)])
 179         return len(b), nil
 180 }