libgo/go/compress/gzip/gunzip_test.go

   1 // Copyright 2009 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 gzip
   6
   7 import (
   8         "bytes"
   9         "compress/flate"
  10         "io"
  11         "io/ioutil"
  12         "os"
  13         "strings"
  14         "testing"
  15         "time"
  16 )
  17
  18 type gunzipTest struct {
  19         name string
  20         desc string
  21         raw  string
  22         gzip []byte
  23         err  error
  24 }
  25
  26 var gunzipTests = []gunzipTest{
  27         { // has 1 empty fixed-huffman block
  28                 "empty.txt",
  29                 "empty.txt",
  30                 "",
  31                 []byte{
  32                         0x1f, 0x8b, 0x08, 0x08, 0xf7, 0x5e, 0x14, 0x4a,
  33                         0x00, 0x03, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e,
  34                         0x74, 0x78, 0x74, 0x00, 0x03, 0x00, 0x00, 0x00,
  35                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  36                 },
  37                 nil,
  38         },
  39         { // has 1 non-empty fixed huffman block
  40                 "hello.txt",
  41                 "hello.txt",
  42                 "hello world\n",
  43                 []byte{
  44                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
  45                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
  46                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
  47                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
  48                         0x02, 0x00, 0x2d, 0x3b, 0x08, 0xaf, 0x0c, 0x00,
  49                         0x00, 0x00,
  50                 },
  51                 nil,
  52         },
  53         { // concatenation
  54                 "hello.txt",
  55                 "hello.txt x2",
  56                 "hello world\n" +
  57                         "hello world\n",
  58                 []byte{
  59                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
  60                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
  61                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
  62                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
  63                         0x02, 0x00, 0x2d, 0x3b, 0x08, 0xaf, 0x0c, 0x00,
  64                         0x00, 0x00,
  65                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
  66                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
  67                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
  68                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
  69                         0x02, 0x00, 0x2d, 0x3b, 0x08, 0xaf, 0x0c, 0x00,
  70                         0x00, 0x00,
  71                 },
  72                 nil,
  73         },
  74         { // has a fixed huffman block with some length-distance pairs
  75                 "shesells.txt",
  76                 "shesells.txt",
  77                 "she sells seashells by the seashore\n",
  78                 []byte{
  79                         0x1f, 0x8b, 0x08, 0x08, 0x72, 0x66, 0x8b, 0x4a,
  80                         0x00, 0x03, 0x73, 0x68, 0x65, 0x73, 0x65, 0x6c,
  81                         0x6c, 0x73, 0x2e, 0x74, 0x78, 0x74, 0x00, 0x2b,
  82                         0xce, 0x48, 0x55, 0x28, 0x4e, 0xcd, 0xc9, 0x29,
  83                         0x06, 0x92, 0x89, 0xc5, 0x19, 0x60, 0x56, 0x52,
  84                         0xa5, 0x42, 0x09, 0x58, 0x18, 0x28, 0x90, 0x5f,
  85                         0x94, 0xca, 0x05, 0x00, 0x76, 0xb0, 0x3b, 0xeb,
  86                         0x24, 0x00, 0x00, 0x00,
  87                 },
  88                 nil,
  89         },
  90         { // has dynamic huffman blocks
  91                 "gettysburg",
  92                 "gettysburg",
  93                 "  Four score and seven years ago our fathers brought forth on\n" +
  94                         "this continent, a new nation, conceived in Liberty, and dedicated\n" +
  95                         "to the proposition that all men are created equal.\n" +
  96                         "  Now we are engaged in a great Civil War, testing whether that\n" +
  97                         "nation, or any nation so conceived and so dedicated, can long\n" +
  98                         "endure.\n" +
  99                         "  We are met on a great battle-field of that war.\n" +
 100                         "  We have come to dedicate a portion of that field, as a final\n" +
 101                         "resting place for those who here gave their lives that that\n" +
 102                         "nation might live.  It is altogether fitting and proper that\n" +
 103                         "we should do this.\n" +
 104                         "  But, in a larger sense, we can not dedicate — we can not\n" +
 105                         "consecrate — we can not hallow — this ground.\n" +
 106                         "  The brave men, living and dead, who struggled here, have\n" +
 107                         "consecrated it, far above our poor power to add or detract.\n" +
 108                         "The world will little note, nor long remember what we say here,\n" +
 109                         "but it can never forget what they did here.\n" +
 110                         "  It is for us the living, rather, to be dedicated here to the\n" +
 111                         "unfinished work which they who fought here have thus far so\n" +
 112                         "nobly advanced.  It is rather for us to be here dedicated to\n" +
 113                         "the great task remaining before us — that from these honored\n" +
 114                         "dead we take increased devotion to that cause for which they\n" +
 115                         "gave the last full measure of devotion —\n" +
 116                         "  that we here highly resolve that these dead shall not have\n" +
 117                         "died in vain — that this nation, under God, shall have a new\n" +
 118                         "birth of freedom — and that government of the people, by the\n" +
 119                         "people, for the people, shall not perish from this earth.\n" +
 120                         "\n" +
 121                         "Abraham Lincoln, November 19, 1863, Gettysburg, Pennsylvania\n",
 122                 []byte{
 123                         0x1f, 0x8b, 0x08, 0x08, 0xd1, 0x12, 0x2b, 0x4a,
 124                         0x00, 0x03, 0x67, 0x65, 0x74, 0x74, 0x79, 0x73,
 125                         0x62, 0x75, 0x72, 0x67, 0x00, 0x65, 0x54, 0xcd,
 126                         0x6e, 0xd4, 0x30, 0x10, 0xbe, 0xfb, 0x29, 0xe6,
 127                         0x01, 0x42, 0xa5, 0x0a, 0x09, 0xc1, 0x11, 0x90,
 128                         0x40, 0x48, 0xa8, 0xe2, 0x80, 0xd4, 0xf3, 0x24,
 129                         0x9e, 0x24, 0x56, 0xbd, 0x9e, 0xc5, 0x76, 0x76,
 130                         0x95, 0x1b, 0x0f, 0xc1, 0x13, 0xf2, 0x24, 0x7c,
 131                         0x63, 0x77, 0x9b, 0x4a, 0x5c, 0xaa, 0x6e, 0x6c,
 132                         0xcf, 0x7c, 0x7f, 0x33, 0x44, 0x5f, 0x74, 0xcb,
 133                         0x54, 0x26, 0xcd, 0x42, 0x9c, 0x3c, 0x15, 0xb9,
 134                         0x48, 0xa2, 0x5d, 0x38, 0x17, 0xe2, 0x45, 0xc9,
 135                         0x4e, 0x67, 0xae, 0xab, 0xe0, 0xf7, 0x98, 0x75,
 136                         0x5b, 0xd6, 0x4a, 0xb3, 0xe6, 0xba, 0x92, 0x26,
 137                         0x57, 0xd7, 0x50, 0x68, 0xd2, 0x54, 0x43, 0x92,
 138                         0x54, 0x07, 0x62, 0x4a, 0x72, 0xa5, 0xc4, 0x35,
 139                         0x68, 0x1a, 0xec, 0x60, 0x92, 0x70, 0x11, 0x4f,
 140                         0x21, 0xd1, 0xf7, 0x30, 0x4a, 0xae, 0xfb, 0xd0,
 141                         0x9a, 0x78, 0xf1, 0x61, 0xe2, 0x2a, 0xde, 0x55,
 142                         0x25, 0xd4, 0xa6, 0x73, 0xd6, 0xb3, 0x96, 0x60,
 143                         0xef, 0xf0, 0x9b, 0x2b, 0x71, 0x8c, 0x74, 0x02,
 144                         0x10, 0x06, 0xac, 0x29, 0x8b, 0xdd, 0x25, 0xf9,
 145                         0xb5, 0x71, 0xbc, 0x73, 0x44, 0x0f, 0x7a, 0xa5,
 146                         0xab, 0xb4, 0x33, 0x49, 0x0b, 0x2f, 0xbd, 0x03,
 147                         0xd3, 0x62, 0x17, 0xe9, 0x73, 0xb8, 0x84, 0x48,
 148                         0x8f, 0x9c, 0x07, 0xaa, 0x52, 0x00, 0x6d, 0xa1,
 149                         0xeb, 0x2a, 0xc6, 0xa0, 0x95, 0x76, 0x37, 0x78,
 150                         0x9a, 0x81, 0x65, 0x7f, 0x46, 0x4b, 0x45, 0x5f,
 151                         0xe1, 0x6d, 0x42, 0xe8, 0x01, 0x13, 0x5c, 0x38,
 152                         0x51, 0xd4, 0xb4, 0x38, 0x49, 0x7e, 0xcb, 0x62,
 153                         0x28, 0x1e, 0x3b, 0x82, 0x93, 0x54, 0x48, 0xf1,
 154                         0xd2, 0x7d, 0xe4, 0x5a, 0xa3, 0xbc, 0x99, 0x83,
 155                         0x44, 0x4f, 0x3a, 0x77, 0x36, 0x57, 0xce, 0xcf,
 156                         0x2f, 0x56, 0xbe, 0x80, 0x90, 0x9e, 0x84, 0xea,
 157                         0x51, 0x1f, 0x8f, 0xcf, 0x90, 0xd4, 0x60, 0xdc,
 158                         0x5e, 0xb4, 0xf7, 0x10, 0x0b, 0x26, 0xe0, 0xff,
 159                         0xc4, 0xd1, 0xe5, 0x67, 0x2e, 0xe7, 0xc8, 0x93,
 160                         0x98, 0x05, 0xb8, 0xa8, 0x45, 0xc0, 0x4d, 0x09,
 161                         0xdc, 0x84, 0x16, 0x2b, 0x0d, 0x9a, 0x21, 0x53,
 162                         0x04, 0x8b, 0xd2, 0x0b, 0xbd, 0xa2, 0x4c, 0xa7,
 163                         0x60, 0xee, 0xd9, 0xe1, 0x1d, 0xd1, 0xb7, 0x4a,
 164                         0x30, 0x8f, 0x63, 0xd5, 0xa5, 0x8b, 0x33, 0x87,
 165                         0xda, 0x1a, 0x18, 0x79, 0xf3, 0xe3, 0xa6, 0x17,
 166                         0x94, 0x2e, 0xab, 0x6e, 0xa0, 0xe3, 0xcd, 0xac,
 167                         0x50, 0x8c, 0xca, 0xa7, 0x0d, 0x76, 0x37, 0xd1,
 168                         0x23, 0xe7, 0x05, 0x57, 0x8b, 0xa4, 0x22, 0x83,
 169                         0xd9, 0x62, 0x52, 0x25, 0xad, 0x07, 0xbb, 0xbf,
 170                         0xbf, 0xff, 0xbc, 0xfa, 0xee, 0x20, 0x73, 0x91,
 171                         0x29, 0xff, 0x7f, 0x02, 0x71, 0x62, 0x84, 0xb5,
 172                         0xf6, 0xb5, 0x25, 0x6b, 0x41, 0xde, 0x92, 0xb7,
 173                         0x76, 0x3f, 0x91, 0x91, 0x31, 0x1b, 0x41, 0x84,
 174                         0x62, 0x30, 0x0a, 0x37, 0xa4, 0x5e, 0x18, 0x3a,
 175                         0x99, 0x08, 0xa5, 0xe6, 0x6d, 0x59, 0x22, 0xec,
 176                         0x33, 0x39, 0x86, 0x26, 0xf5, 0xab, 0x66, 0xc8,
 177                         0x08, 0x20, 0xcf, 0x0c, 0xd7, 0x47, 0x45, 0x21,
 178                         0x0b, 0xf6, 0x59, 0xd5, 0xfe, 0x5c, 0x8d, 0xaa,
 179                         0x12, 0x7b, 0x6f, 0xa1, 0xf0, 0x52, 0x33, 0x4f,
 180                         0xf5, 0xce, 0x59, 0xd3, 0xab, 0x66, 0x10, 0xbf,
 181                         0x06, 0xc4, 0x31, 0x06, 0x73, 0xd6, 0x80, 0xa2,
 182                         0x78, 0xc2, 0x45, 0xcb, 0x03, 0x65, 0x39, 0xc9,
 183                         0x09, 0xd1, 0x06, 0x04, 0x33, 0x1a, 0x5a, 0xf1,
 184                         0xde, 0x01, 0xb8, 0x71, 0x83, 0xc4, 0xb5, 0xb3,
 185                         0xc3, 0x54, 0x65, 0x33, 0x0d, 0x5a, 0xf7, 0x9b,
 186                         0x90, 0x7c, 0x27, 0x1f, 0x3a, 0x58, 0xa3, 0xd8,
 187                         0xfd, 0x30, 0x5f, 0xb7, 0xd2, 0x66, 0xa2, 0x93,
 188                         0x1c, 0x28, 0xb7, 0xe9, 0x1b, 0x0c, 0xe1, 0x28,
 189                         0x47, 0x26, 0xbb, 0xe9, 0x7d, 0x7e, 0xdc, 0x96,
 190                         0x10, 0x92, 0x50, 0x56, 0x7c, 0x06, 0xe2, 0x27,
 191                         0xb4, 0x08, 0xd3, 0xda, 0x7b, 0x98, 0x34, 0x73,
 192                         0x9f, 0xdb, 0xf6, 0x62, 0xed, 0x31, 0x41, 0x13,
 193                         0xd3, 0xa2, 0xa8, 0x4b, 0x3a, 0xc6, 0x1d, 0xe4,
 194                         0x2f, 0x8c, 0xf8, 0xfb, 0x97, 0x64, 0xf4, 0xb6,
 195                         0x2f, 0x80, 0x5a, 0xf3, 0x56, 0xe0, 0x40, 0x50,
 196                         0xd5, 0x19, 0xd0, 0x1e, 0xfc, 0xca, 0xe5, 0xc9,
 197                         0xd4, 0x60, 0x00, 0x81, 0x2e, 0xa3, 0xcc, 0xb6,
 198                         0x52, 0xf0, 0xb4, 0xdb, 0x69, 0x99, 0xce, 0x7a,
 199                         0x32, 0x4c, 0x08, 0xed, 0xaa, 0x10, 0x10, 0xe3,
 200                         0x6f, 0xee, 0x99, 0x68, 0x95, 0x9f, 0x04, 0x71,
 201                         0xb2, 0x49, 0x2f, 0x62, 0xa6, 0x5e, 0xb4, 0xef,
 202                         0x02, 0xed, 0x4f, 0x27, 0xde, 0x4a, 0x0f, 0xfd,
 203                         0xc1, 0xcc, 0xdd, 0x02, 0x8f, 0x08, 0x16, 0x54,
 204                         0xdf, 0xda, 0xca, 0xe0, 0x82, 0xf1, 0xb4, 0x31,
 205                         0x7a, 0xa9, 0x81, 0xfe, 0x90, 0xb7, 0x3e, 0xdb,
 206                         0xd3, 0x35, 0xc0, 0x20, 0x80, 0x33, 0x46, 0x4a,
 207                         0x63, 0xab, 0xd1, 0x0d, 0x29, 0xd2, 0xe2, 0x84,
 208                         0xb8, 0xdb, 0xfa, 0xe9, 0x89, 0x44, 0x86, 0x7c,
 209                         0xe8, 0x0b, 0xe6, 0x02, 0x6a, 0x07, 0x9b, 0x96,
 210                         0xd0, 0xdb, 0x2e, 0x41, 0x4c, 0xa1, 0xd5, 0x57,
 211                         0x45, 0x14, 0xfb, 0xe3, 0xa6, 0x72, 0x5b, 0x87,
 212                         0x6e, 0x0c, 0x6d, 0x5b, 0xce, 0xe0, 0x2f, 0xe2,
 213                         0x21, 0x81, 0x95, 0xb0, 0xe8, 0xb6, 0x32, 0x0b,
 214                         0xb2, 0x98, 0x13, 0x52, 0x5d, 0xfb, 0xec, 0x63,
 215                         0x17, 0x8a, 0x9e, 0x23, 0x22, 0x36, 0xee, 0xcd,
 216                         0xda, 0xdb, 0xcf, 0x3e, 0xf1, 0xc7, 0xf1, 0x01,
 217                         0x12, 0x93, 0x0a, 0xeb, 0x6f, 0xf2, 0x02, 0x15,
 218                         0x96, 0x77, 0x5d, 0xef, 0x9c, 0xfb, 0x88, 0x91,
 219                         0x59, 0xf9, 0x84, 0xdd, 0x9b, 0x26, 0x8d, 0x80,
 220                         0xf9, 0x80, 0x66, 0x2d, 0xac, 0xf7, 0x1f, 0x06,
 221                         0xba, 0x7f, 0xff, 0xee, 0xed, 0x40, 0x5f, 0xa5,
 222                         0xd6, 0xbd, 0x8c, 0x5b, 0x46, 0xd2, 0x7e, 0x48,
 223                         0x4a, 0x65, 0x8f, 0x08, 0x42, 0x60, 0xf7, 0x0f,
 224                         0xb9, 0x16, 0x0b, 0x0c, 0x1a, 0x06, 0x00, 0x00,
 225                 },
 226                 nil,
 227         },
 228         { // has 1 non-empty fixed huffman block then garbage
 229                 "hello.txt",
 230                 "hello.txt + garbage",
 231                 "hello world\n",
 232                 []byte{
 233                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
 234                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
 235                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
 236                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
 237                         0x02, 0x00, 0x2d, 0x3b, 0x08, 0xaf, 0x0c, 0x00,
 238                         0x00, 0x00, 'g', 'a', 'r', 'b', 'a', 'g', 'e', '!', '!', '!',
 239                 },
 240                 ErrHeader,
 241         },
 242         { // has 1 non-empty fixed huffman block not enough header
 243                 "hello.txt",
 244                 "hello.txt + garbage",
 245                 "hello world\n",
 246                 []byte{
 247                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
 248                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
 249                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
 250                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
 251                         0x02, 0x00, 0x2d, 0x3b, 0x08, 0xaf, 0x0c, 0x00,
 252                         0x00, 0x00, gzipID1,
 253                 },
 254                 io.ErrUnexpectedEOF,
 255         },
 256         { // has 1 non-empty fixed huffman block but corrupt checksum
 257                 "hello.txt",
 258                 "hello.txt + corrupt checksum",
 259                 "hello world\n",
 260                 []byte{
 261                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
 262                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
 263                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
 264                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
 265                         0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00,
 266                         0x00, 0x00,
 267                 },
 268                 ErrChecksum,
 269         },
 270         { // has 1 non-empty fixed huffman block but corrupt size
 271                 "hello.txt",
 272                 "hello.txt + corrupt size",
 273                 "hello world\n",
 274                 []byte{
 275                         0x1f, 0x8b, 0x08, 0x08, 0xc8, 0x58, 0x13, 0x4a,
 276                         0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
 277                         0x74, 0x78, 0x74, 0x00, 0xcb, 0x48, 0xcd, 0xc9,
 278                         0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
 279                         0x02, 0x00, 0x2d, 0x3b, 0x08, 0xaf, 0xff, 0x00,
 280                         0x00, 0x00,
 281                 },
 282                 ErrChecksum,
 283         },
 284 }
 285
 286 func TestDecompressor(t *testing.T) {
 287         b := new(bytes.Buffer)
 288         for _, tt := range gunzipTests {
 289                 in := bytes.NewReader(tt.gzip)
 290                 gzip, err := NewReader(in)
 291                 if err != nil {
 292                         t.Errorf("%s: NewReader: %s", tt.name, err)
 293                         continue
 294                 }
 295                 defer gzip.Close()
 296                 if tt.name != gzip.Name {
 297                         t.Errorf("%s: got name %s", tt.name, gzip.Name)
 298                 }
 299                 b.Reset()
 300                 n, err := io.Copy(b, gzip)
 301                 if err != tt.err {
 302                         t.Errorf("%s: io.Copy: %v want %v", tt.name, err, tt.err)
 303                 }
 304                 s := b.String()
 305                 if s != tt.raw {
 306                         t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.name, n, s, len(tt.raw), tt.raw)
 307                 }
 308
 309                 // Test Reader Reset.
 310                 in = bytes.NewReader(tt.gzip)
 311                 err = gzip.Reset(in)
 312                 if err != nil {
 313                         t.Errorf("%s: Reset: %s", tt.name, err)
 314                         continue
 315                 }
 316                 if tt.name != gzip.Name {
 317                         t.Errorf("%s: got name %s", tt.name, gzip.Name)
 318                 }
 319                 b.Reset()
 320                 n, err = io.Copy(b, gzip)
 321                 if err != tt.err {
 322                         t.Errorf("%s: io.Copy: %v want %v", tt.name, err, tt.err)
 323                 }
 324                 s = b.String()
 325                 if s != tt.raw {
 326                         t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.name, n, s, len(tt.raw), tt.raw)
 327                 }
 328         }
 329 }
 330
 331 func TestIssue6550(t *testing.T) {
 332         f, err := os.Open("testdata/issue6550.gz")
 333         if err != nil {
 334                 t.Fatal(err)
 335         }
 336         gzip, err := NewReader(f)
 337         if err != nil {
 338                 t.Fatalf("NewReader(testdata/issue6550.gz): %v", err)
 339         }
 340         defer gzip.Close()
 341         done := make(chan bool, 1)
 342         go func() {
 343                 _, err := io.Copy(ioutil.Discard, gzip)
 344                 if err == nil {
 345                         t.Errorf("Copy succeeded")
 346                 } else {
 347                         t.Logf("Copy failed (correctly): %v", err)
 348                 }
 349                 done <- true
 350         }()
 351         select {
 352         case <-time.After(1 * time.Second):
 353                 t.Errorf("Copy hung")
 354         case <-done:
 355                 // ok
 356         }
 357 }
 358
 359 func TestInitialReset(t *testing.T) {
 360         var r Reader
 361         if err := r.Reset(bytes.NewReader(gunzipTests[1].gzip)); err != nil {
 362                 t.Error(err)
 363         }
 364         var buf bytes.Buffer
 365         if _, err := io.Copy(&buf, &r); err != nil {
 366                 t.Error(err)
 367         }
 368         if s := buf.String(); s != gunzipTests[1].raw {
 369                 t.Errorf("got %q want %q", s, gunzipTests[1].raw)
 370         }
 371 }
 372
 373 func TestMultistreamFalse(t *testing.T) {
 374         // Find concatenation test.
 375         var tt gunzipTest
 376         for _, tt = range gunzipTests {
 377                 if strings.HasSuffix(tt.desc, " x2") {
 378                         goto Found
 379                 }
 380         }
 381         t.Fatal("cannot find hello.txt x2 in gunzip tests")
 382
 383 Found:
 384         br := bytes.NewReader(tt.gzip)
 385         var r Reader
 386         if err := r.Reset(br); err != nil {
 387                 t.Fatalf("first reset: %v", err)
 388         }
 389
 390         // Expect two streams with "hello world\n", then real EOF.
 391         const hello = "hello world\n"
 392
 393         r.Multistream(false)
 394         data, err := ioutil.ReadAll(&r)
 395         if string(data) != hello || err != nil {
 396                 t.Fatalf("first stream = %q, %v, want %q, %v", string(data), err, hello, nil)
 397         }
 398
 399         if err := r.Reset(br); err != nil {
 400                 t.Fatalf("second reset: %v", err)
 401         }
 402         r.Multistream(false)
 403         data, err = ioutil.ReadAll(&r)
 404         if string(data) != hello || err != nil {
 405                 t.Fatalf("second stream = %q, %v, want %q, %v", string(data), err, hello, nil)
 406         }
 407
 408         if err := r.Reset(br); err != io.EOF {
 409                 t.Fatalf("third reset: err=%v, want io.EOF", err)
 410         }
 411 }
 412
 413 func TestNilStream(t *testing.T) {
 414         // Go liberally interprets RFC1952 section 2.2 to mean that a gzip file
 415         // consist of zero or more members. Thus, we test that a nil stream is okay.
 416         _, err := NewReader(bytes.NewReader(nil))
 417         if err != io.EOF {
 418                 t.Fatalf("NewReader(nil) on empty stream: got %v, want io.EOF", err)
 419         }
 420 }
 421
 422 func TestTruncatedStreams(t *testing.T) {
 423         const data = "\x1f\x8b\b\x04\x00\tn\x88\x00\xff\a\x00foo bar\xcbH\xcd\xc9\xc9\xd7Q(\xcf/\xcaI\x01\x04:r\xab\xff\f\x00\x00\x00"
 424
 425         // Intentionally iterate starting with at least one byte in the stream.
 426         for i := 1; i < len(data)-1; i++ {
 427                 r, err := NewReader(strings.NewReader(data[:i]))
 428                 if err != nil {
 429                         if err != io.ErrUnexpectedEOF {
 430                                 t.Errorf("NewReader(%d) on truncated stream: got %v, want %v", i, err, io.ErrUnexpectedEOF)
 431                         }
 432                         continue
 433                 }
 434                 _, err = io.Copy(ioutil.Discard, r)
 435                 if ferr, ok := err.(*flate.ReadError); ok {
 436                         err = ferr.Err
 437                 }
 438                 if err != io.ErrUnexpectedEOF {
 439                         t.Errorf("io.Copy(%d) on truncated stream: got %v, want %v", i, err, io.ErrUnexpectedEOF)
 440                 }
 441         }
 442 }