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 zlib 6 7 import ( 8 "bytes" 9 "fmt" 10 "internal/testenv" 11 "io" 12 "io/ioutil" 13 "os" 14 "testing" 15 ) 16 17 var filenames = []string{ 18 "../testdata/gettysburg.txt", 19 "../testdata/e.txt", 20 "../testdata/pi.txt", 21 } 22 23 var data = []string{ 24 "test a reasonable sized string that can be compressed", 25 } 26 27 // Tests that compressing and then decompressing the given file at the given compression level and dictionary 28 // yields equivalent bytes to the original file. 29 func testFileLevelDict(t *testing.T, fn string, level int, d string) { 30 // Read the file, as golden output. 31 golden, err := os.Open(fn) 32 if err != nil { 33 t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err) 34 return 35 } 36 defer golden.Close() 37 b0, err0 := ioutil.ReadAll(golden) 38 if err0 != nil { 39 t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err0) 40 return 41 } 42 testLevelDict(t, fn, b0, level, d) 43 } 44 45 func testLevelDict(t *testing.T, fn string, b0 []byte, level int, d string) { 46 // Make dictionary, if given. 47 var dict []byte 48 if d != "" { 49 dict = []byte(d) 50 } 51 52 // Push data through a pipe that compresses at the write end, and decompresses at the read end. 53 piper, pipew := io.Pipe() 54 defer piper.Close() 55 go func() { 56 defer pipew.Close() 57 zlibw, err := NewWriterLevelDict(pipew, level, dict) 58 if err != nil { 59 t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err) 60 return 61 } 62 defer zlibw.Close() 63 _, err = zlibw.Write(b0) 64 if err != nil { 65 t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err) 66 return 67 } 68 }() 69 zlibr, err := NewReaderDict(piper, dict) 70 if err != nil { 71 t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err) 72 return 73 } 74 defer zlibr.Close() 75 76 // Compare the decompressed data. 77 b1, err1 := ioutil.ReadAll(zlibr) 78 if err1 != nil { 79 t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err1) 80 return 81 } 82 if len(b0) != len(b1) { 83 t.Errorf("%s (level=%d, dict=%q): length mismatch %d versus %d", fn, level, d, len(b0), len(b1)) 84 return 85 } 86 for i := 0; i < len(b0); i++ { 87 if b0[i] != b1[i] { 88 t.Errorf("%s (level=%d, dict=%q): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, d, i, b0[i], b1[i]) 89 return 90 } 91 } 92 } 93 94 func testFileLevelDictReset(t *testing.T, fn string, level int, dict []byte) { 95 var b0 []byte 96 var err error 97 if fn != "" { 98 b0, err = ioutil.ReadFile(fn) 99 if err != nil { 100 t.Errorf("%s (level=%d): %v", fn, level, err) 101 return 102 } 103 } 104 105 // Compress once. 106 buf := new(bytes.Buffer) 107 var zlibw *Writer 108 if dict == nil { 109 zlibw, err = NewWriterLevel(buf, level) 110 } else { 111 zlibw, err = NewWriterLevelDict(buf, level, dict) 112 } 113 if err == nil { 114 _, err = zlibw.Write(b0) 115 } 116 if err == nil { 117 err = zlibw.Close() 118 } 119 if err != nil { 120 t.Errorf("%s (level=%d): %v", fn, level, err) 121 return 122 } 123 out := buf.String() 124 125 // Reset and compress again. 126 buf2 := new(bytes.Buffer) 127 zlibw.Reset(buf2) 128 _, err = zlibw.Write(b0) 129 if err == nil { 130 err = zlibw.Close() 131 } 132 if err != nil { 133 t.Errorf("%s (level=%d): %v", fn, level, err) 134 return 135 } 136 out2 := buf2.String() 137 138 if out2 != out { 139 t.Errorf("%s (level=%d): different output after reset (got %d bytes, expected %d", 140 fn, level, len(out2), len(out)) 141 } 142 } 143 144 func TestWriter(t *testing.T) { 145 for i, s := range data { 146 b := []byte(s) 147 tag := fmt.Sprintf("#%d", i) 148 testLevelDict(t, tag, b, DefaultCompression, "") 149 testLevelDict(t, tag, b, NoCompression, "") 150 testLevelDict(t, tag, b, HuffmanOnly, "") 151 for level := BestSpeed; level <= BestCompression; level++ { 152 testLevelDict(t, tag, b, level, "") 153 } 154 } 155 } 156 157 func TestWriterBig(t *testing.T) { 158 for i, fn := range filenames { 159 testFileLevelDict(t, fn, DefaultCompression, "") 160 testFileLevelDict(t, fn, NoCompression, "") 161 testFileLevelDict(t, fn, HuffmanOnly, "") 162 for level := BestSpeed; level <= BestCompression; level++ { 163 testFileLevelDict(t, fn, level, "") 164 if level >= 1 && testing.Short() && testenv.Builder() == "" { 165 break 166 } 167 } 168 if i == 0 && testing.Short() && testenv.Builder() == "" { 169 break 170 } 171 } 172 } 173 174 func TestWriterDict(t *testing.T) { 175 const dictionary = "0123456789." 176 for i, fn := range filenames { 177 testFileLevelDict(t, fn, DefaultCompression, dictionary) 178 testFileLevelDict(t, fn, NoCompression, dictionary) 179 testFileLevelDict(t, fn, HuffmanOnly, dictionary) 180 for level := BestSpeed; level <= BestCompression; level++ { 181 testFileLevelDict(t, fn, level, dictionary) 182 if level >= 1 && testing.Short() && testenv.Builder() == "" { 183 break 184 } 185 } 186 if i == 0 && testing.Short() && testenv.Builder() == "" { 187 break 188 } 189 } 190 } 191 192 func TestWriterReset(t *testing.T) { 193 const dictionary = "0123456789." 194 for _, fn := range filenames { 195 testFileLevelDictReset(t, fn, NoCompression, nil) 196 testFileLevelDictReset(t, fn, DefaultCompression, nil) 197 testFileLevelDictReset(t, fn, HuffmanOnly, nil) 198 testFileLevelDictReset(t, fn, NoCompression, []byte(dictionary)) 199 testFileLevelDictReset(t, fn, DefaultCompression, []byte(dictionary)) 200 testFileLevelDictReset(t, fn, HuffmanOnly, []byte(dictionary)) 201 if testing.Short() { 202 break 203 } 204 for level := BestSpeed; level <= BestCompression; level++ { 205 testFileLevelDictReset(t, fn, level, nil) 206 } 207 } 208 } 209 210 func TestWriterDictIsUsed(t *testing.T) { 211 var input = []byte("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.") 212 var buf bytes.Buffer 213 compressor, err := NewWriterLevelDict(&buf, BestCompression, input) 214 if err != nil { 215 t.Errorf("error in NewWriterLevelDict: %s", err) 216 return 217 } 218 compressor.Write(input) 219 compressor.Close() 220 const expectedMaxSize = 25 221 output := buf.Bytes() 222 if len(output) > expectedMaxSize { 223 t.Errorf("result too large (got %d, want <= %d bytes). Is the dictionary being used?", len(output), expectedMaxSize) 224 } 225 } 226
