pr-zlib 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/CHANGES ADDED
@@ -0,0 +1,2 @@
1
+ = 1.0.0 - 12-Jun-2009
2
+ * Initial release
data/MANIFEST ADDED
@@ -0,0 +1,18 @@
1
+ CHANGES
2
+ MANIFEST
3
+ README
4
+ pr-zlib.gemspec
5
+ bin/minizip.rb
6
+ examples/example_rbzlib.rb
7
+ lib/pr/rbzlib.rb
8
+ lib/pr/zlib.rb
9
+ test/test_rbzlib_bytef.rb
10
+ test/test_rbzlib_posf.rb
11
+ test/test_rbzlib.rb
12
+ test/test_zlib_deflate.rb
13
+ test/test_zlib_gzip_file.rb
14
+ test/test_zlib_gzip_reader.rb
15
+ test/test_zlib_gzip_writer.rb
16
+ test/test_zlib_inflate.rb
17
+ test/test_zlib_zstream.rb
18
+ test/test_zlib.rb
data/README ADDED
@@ -0,0 +1,42 @@
1
+ = Description
2
+ The pr-zlib library is a pure Ruby version of the zlib compression library.
3
+ It consists of both a port of zlib.h and the Ruby zlib library that ships as
4
+ part of the standard library.
5
+
6
+ = Synopsis
7
+
8
+ # Imitating a bit of code used in rubygems
9
+ require 'pr/zlib'
10
+ require 'stringio'
11
+
12
+ data = StringIO.new(data)
13
+ Zlib::GzipReader.new(data).read
14
+
15
+ = Motivation
16
+
17
+ First, building the zlib C library on MS Windows with Visual C++ is very
18
+ difficult. However, certain libraries depend on zlib, most notably rubygems.
19
+ By providing a pure Ruby version we eliminate any compiler or platform
20
+ compatability issues.
21
+
22
+ Second, even some Unix distributions, such as Debian, do not ship with
23
+ the zlib library by default. By creating a pure Ruby version of the zlib
24
+ library we eliminate the need to install a 3rd party C library, and
25
+ eliminate a potential weak link in the dependency chain.
26
+
27
+ Third, by creating pure Ruby versions of the library and the interface we
28
+ are more likely to receive patches, feature requests, documentation updates,
29
+ etc, from the Ruby community since not everyone who knows Ruby also knows C.
30
+
31
+ Last, the zlib interface that ships as part of the stdlib is a little on the
32
+ clunky side. By providing a pure Ruby version, authors can create their own
33
+ interface as they see fit.
34
+
35
+ = TODO
36
+
37
+ More tests, and better tests, are needed for both Rbzlib and Zlib.
38
+
39
+ = Authors
40
+
41
+ * Park Heesob (C translation)
42
+ * Daniel Berger (Testing, packaging, deployment)
data/Rakefile ADDED
@@ -0,0 +1,88 @@
1
+ require 'rake'
2
+ require 'rake/testtask'
3
+ require 'rbconfig'
4
+
5
+ desc 'Install the pr-zlib library'
6
+ task :install do
7
+ install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
8
+ Dir.mkdir(install_dir) unless File.exists?(install_dir)
9
+ files = ['lib/pr/zlib.rb', 'lib/pr/rbzlib.rb']
10
+ files.each{ |file|
11
+ FileUtils.cp(file, install_dir, :verbose => true)
12
+ }
13
+ end
14
+
15
+ desc 'Install the pr-zlib library as zlib'
16
+ task :install_as_zlib do
17
+ install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
18
+ Dir.mkdir(install_dir) unless File.exists?(install_dir)
19
+
20
+ FileUtils.cp('lib/pr/zlib.rb', Config::CONFIG['sitelibdir'], :verbose => true)
21
+ FileUtils.cp('lib/pr/rbzlib.rb', install_dir, :verbose => true)
22
+ end
23
+
24
+ desc 'Install the pr-zlib library as a gem'
25
+ task :install_gem do
26
+ ruby 'pr-zlib.gemspec'
27
+ file = Dir["*.gem"].first
28
+ sh "gem install #{file}"
29
+ end
30
+
31
+ Rake::TestTask.new do |t|
32
+ t.warning = true
33
+ t.verbose = true
34
+ end
35
+
36
+ Rake::TestTask.new('test_zlib') do |t|
37
+ t.warning = true
38
+ t.verbose = true
39
+ t.test_files = FileList['test/test_zlib.rb']
40
+ end
41
+
42
+ Rake::TestTask.new('test_gzip_file') do |t|
43
+ t.warning = true
44
+ t.verbose = true
45
+ t.test_files = FileList['test/test_zlib_gzip_file.rb']
46
+ end
47
+
48
+ Rake::TestTask.new('test_gzip_reader') do |t|
49
+ t.warning = true
50
+ t.verbose = true
51
+ t.test_files = FileList['test/test_zlib_gzip_reader.rb']
52
+ end
53
+
54
+ Rake::TestTask.new('test_gzip_writer') do |t|
55
+ t.warning = true
56
+ t.verbose = true
57
+ t.test_files = FileList['test/test_zlib_gzip_writer.rb']
58
+ end
59
+
60
+ Rake::TestTask.new('test_deflate') do |t|
61
+ t.warning = true
62
+ t.verbose = true
63
+ t.test_files = FileList['test/test_zlib_deflate.rb']
64
+ end
65
+
66
+ Rake::TestTask.new('test_inflate') do |t|
67
+ t.warning = true
68
+ t.verbose = true
69
+ t.test_files = FileList['test/test_zlib_inflate.rb']
70
+ end
71
+
72
+ Rake::TestTask.new('test_rbzlib') do |t|
73
+ t.warning = true
74
+ t.verbose = true
75
+ t.test_files = FileList['test/test_rbzlib.rb']
76
+ end
77
+
78
+ Rake::TestTask.new('test_rbzlib_bytef') do |t|
79
+ t.warning = true
80
+ t.verbose = true
81
+ t.test_files = FileList['test/test_rbzlib_bytef.rb']
82
+ end
83
+
84
+ Rake::TestTask.new('test_rbzlib_posf') do |t|
85
+ t.warning = true
86
+ t.verbose = true
87
+ t.test_files = FileList['test/test_rbzlib_posf.rb']
88
+ end
data/bin/minizip.rb ADDED
@@ -0,0 +1,173 @@
1
+ # minigzip.rb -- simulate gzip using the zlib compression library
2
+ # Copyright (C) 1995-2005 Jean-loup Gailly.
3
+ # For conditions of distribution and use, see copyright notice in rbzlib.rb
4
+ #
5
+ #
6
+ #
7
+ # minigzip is a minimal implementation of the gzip utility. This is
8
+ # only an example of using zlib and isn't meant to replace the
9
+ # full-featured gzip. No attempt is made to deal with file systems
10
+ # limiting names to 14 or 8+3 characters, etc... Error checking is
11
+ # very limited. So use minigzip only for testing; use gzip for the
12
+ # real thing. On MSDOS, use only on file names without extension
13
+ # or in pipe mode.
14
+ #
15
+ # Ruby tralnslation By Park Heesob.
16
+
17
+ require 'rbzlib'
18
+ include Rbzlib
19
+
20
+ GZ_SUFFIX = ".gz"
21
+ SUFFIX_LEN = GZ_SUFFIX.length
22
+
23
+ BUFLEN = 16384
24
+ MAX_NAME_LEN = 1024
25
+
26
+
27
+ def error(msg)
28
+ puts("#{__FILE__}: #{msg}")
29
+ exit(1)
30
+ end
31
+
32
+ def gz_compress(_in, out)
33
+ while(true)
34
+ begin
35
+ buf = _in.read(BUFLEN)
36
+ rescue
37
+ raise RuntimeError,"read"
38
+ end
39
+ break if buf.nil?
40
+ err = 0
41
+ len = buf.length
42
+ if (gzwrite(out, buf, len) != len)
43
+ error(gzerror(out, err))
44
+ end
45
+ end
46
+ _in.close
47
+ error("failed gzclose") if (gzclose(out) != Z_OK)
48
+ end
49
+
50
+
51
+ def gz_uncompress(_in, out)
52
+ buf = 0.chr * BUFLEN
53
+ while true
54
+ len = gzread(_in, buf, buf.length)
55
+ err = 0
56
+ error(gzerror(_in, err)) if (len < 0)
57
+ break if len.zero?
58
+ if(out.write(buf[0,len]) != len)
59
+ error("failed write")
60
+ end
61
+ end
62
+ begin
63
+ out.close
64
+ rescue
65
+ error("failed fclose")
66
+ end
67
+
68
+ error("failed gzclose") if (gzclose(_in) != Z_OK)
69
+ end
70
+
71
+
72
+ def file_compress(file, mode)
73
+ outfile = file + GZ_SUFFIX
74
+
75
+ _in = File.open(file, "rb")
76
+ if _in.nil?
77
+ raise RuntimeError,file
78
+ end
79
+ out = gzopen(outfile, mode)
80
+ if out.nil?
81
+ puts("#{__FILE__}: can't gzopen #{outfile}")
82
+ exit(1)
83
+ end
84
+ gz_compress(_in, out)
85
+
86
+ File.unlink(file)
87
+ end
88
+
89
+
90
+ def file_uncompress(file)
91
+ len = file.length
92
+ buf = file.dup
93
+
94
+ if (file[-SUFFIX_LEN..-1] == GZ_SUFFIX)
95
+ infile = file.dup
96
+ outfile = buf[0..(-SUFFIX_LEN-1)]
97
+ else
98
+ outfile = file.dup
99
+ infile = buf + GZ_SUFFIX
100
+ end
101
+ _in = gzopen(infile, "rb")
102
+ if _in.nil?
103
+ puts("#{__FILE__}: can't gzopen #{infile}")
104
+ exit(1)
105
+ end
106
+ out = File.open(outfile, "wb")
107
+ if out.nil?
108
+ raise RuntimeError,file
109
+ exit(1)
110
+ end
111
+
112
+ gz_uncompress(_in, out)
113
+
114
+ File.unlink(infile)
115
+ end
116
+
117
+
118
+ #===========================================================================
119
+ # Usage: minigzip [-d] [-f] [-h] [-r] [-1 to -9] [files...]
120
+ # -d : decompress
121
+ # -f : compress with Z_FILTERED
122
+ # -h : compress with Z_HUFFMAN_ONLY
123
+ # -r : compress with Z_RLE
124
+ # -1 to -9 : compression level
125
+ #
126
+
127
+ uncompr = false
128
+
129
+ outmode = "wb6 "
130
+
131
+ while !ARGV.empty?
132
+ argv = ARGV.shift
133
+ case argv
134
+ when "-d"
135
+ uncompr = true
136
+ when "-f"
137
+ outmode[3] = 'f'
138
+ when "-h"
139
+ outmode[3] = 'h'
140
+ when "-r"
141
+ outmode[3] = 'R'
142
+ when "-1".."-9"
143
+ outmode[2] = argv[1]
144
+ else
145
+ ARGV.unshift(argv)
146
+ break
147
+ end
148
+ end
149
+ if (outmode[3].chr == ' ')
150
+ outmode = outmode[0,3]
151
+ end
152
+ if (ARGV.empty?)
153
+ $stdin.binmode
154
+ $stdout.binmode
155
+ if (uncompr)
156
+ file = gzdopen($stdin.fileno, "rb")
157
+ error("can't gzdopen stdin") if file.nil?
158
+ gz_uncompress(file, $stdout)
159
+ else
160
+ file = gzdopen($stdout.fileno, outmode)
161
+ error("can't gzdopen stdout") if file.nil?
162
+ gz_compress($stdin, file)
163
+ end
164
+ else
165
+ while !ARGV.empty?
166
+ if (uncompr)
167
+ file_uncompress(ARGV.shift)
168
+ else
169
+ file_compress(ARGV.shift, outmode)
170
+ end
171
+ end
172
+ end
173
+
@@ -0,0 +1,385 @@
1
+ # example.rb -- usage example of the zlib compression library
2
+ # Copyright (C) 1995-2004 Jean-loup Gailly.
3
+ # For conditions of distribution and use, see copyright notice in rbzlib.rb
4
+ #
5
+ # Ruby translation by Park Heesob
6
+
7
+ require 'rbzlib'
8
+ include Rbzlib
9
+
10
+ def CHECK_ERR(err,msg)
11
+ if(err != Z_OK)
12
+ raise RuntimeError,"#{msg} error: #{err}"
13
+ end
14
+ end
15
+
16
+ TESTFILE = "foo.gz"
17
+ @@hello = "hello, hello!\0"
18
+
19
+ @@dictionary = "hello"
20
+
21
+ def test_compress(compr, comprLen, uncompr, uncomprLen)
22
+ len = @@hello.length
23
+
24
+ err,comprLen = compress(compr, comprLen, @@hello, len)
25
+ CHECK_ERR(err, "compress")
26
+ compr = compr[0,comprLen]
27
+ uncompr[0,7] = "garbage"
28
+ err,uncomprLen = uncompress(uncompr, uncomprLen, compr, comprLen)
29
+ CHECK_ERR(err, "uncompress")
30
+ uncompr = uncompr[0,uncomprLen]
31
+ if uncompr != @@hello
32
+ puts("bad uncompress")
33
+ exit(1)
34
+ else
35
+ puts("uncompress(): #{uncompr}")
36
+ end
37
+ end
38
+
39
+ def test_gzio(fname, uncompr, uncomprLen)
40
+ len = @@hello.length
41
+ err = 0
42
+ file = gzopen(fname, "wb")
43
+ if file.nil?
44
+ puts("gzopen error")
45
+ exit(1)
46
+ end
47
+ gzputc(file, 'h')
48
+ if (gzputs(file, "ello") != 4)
49
+ puts("gzputs err: #{gzerror(file, err)}")
50
+ exit(1)
51
+ end
52
+ if (gzputs(file, ", hello!") != 8)
53
+ puts("gzputs err: #{gzerror(file, err)}")
54
+ exit(1)
55
+ end
56
+ gzseek(file, 1, SEEK_CUR)
57
+ gzclose(file)
58
+
59
+ file = gzopen(fname, "rb")
60
+ if file.nil?
61
+ puts("gzopen error")
62
+ exit(1)
63
+ end
64
+ uncompr[0,7] = "garbage"
65
+ if (gzread(file, uncompr, uncomprLen) != len)
66
+ puts("gzread err: #{gzerror(file, err)}")
67
+ exit(1)
68
+ end
69
+ uncompr = uncompr[0,len]
70
+ if uncompr != @@hello
71
+ puts("bad gzread: #{uncompr}")
72
+ exit(1)
73
+ else
74
+ puts("gzread(): #{uncompr}")
75
+ end
76
+ pos = gzseek(file, -8, SEEK_CUR)
77
+ if (pos != 6 || gztell(file) != pos)
78
+ puts("gzseek error, pos=#{pos}, gztell=#{gztell(file)}")
79
+ exit(1)
80
+ end
81
+
82
+ if (gzgetc(file) != ' ')
83
+ puts("gzgetc error")
84
+ exit(1)
85
+ end
86
+
87
+ if (gzungetc(' ', file) != ' ')
88
+ puts("gzungetc error")
89
+ exit(1)
90
+ end
91
+
92
+ gzgets(file, uncompr, uncomprLen)
93
+ uncompr.chop!
94
+ if uncompr.length != 7
95
+ puts("gzgets err after gzseek: #{gzerror(file, err)}")
96
+ exit(1)
97
+ end
98
+
99
+ if uncompr != @@hello[6..-2]
100
+ puts("bad gzgets after gzseek")
101
+ exit(1)
102
+ else
103
+ puts("gzgets() after gzseek: #{uncompr}")
104
+ end
105
+
106
+ gzclose(file)
107
+ end
108
+
109
+ def test_deflate(compr, comprLen)
110
+ c_stream = Z_stream.new
111
+ len = @@hello.length
112
+
113
+ err = deflateInit(c_stream, Z_DEFAULT_COMPRESSION)
114
+ CHECK_ERR(err, "deflateInit")
115
+
116
+ c_stream.next_in = Bytef.new(@@hello)
117
+ c_stream.next_out = Bytef.new(compr)
118
+
119
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
120
+ c_stream.avail_in = c_stream.avail_out = 1
121
+ err = deflate(c_stream, Z_NO_FLUSH)
122
+ CHECK_ERR(err, "deflate")
123
+ end
124
+ while true
125
+ c_stream.avail_out = 1
126
+ err = deflate(c_stream, Z_FINISH)
127
+ break if (err == Z_STREAM_END)
128
+ CHECK_ERR(err, "deflate")
129
+ end
130
+
131
+ err = deflateEnd(c_stream)
132
+ CHECK_ERR(err, "deflateEnd")
133
+ end
134
+
135
+ def test_inflate(compr, comprLen, uncompr, uncomprLen)
136
+ uncompr[0,7] = "garbage"
137
+ d_stream = Z_stream.new
138
+
139
+ d_stream.next_in = Bytef.new(compr)
140
+ d_stream.avail_in = 0
141
+ d_stream.next_out = Bytef.new(uncompr)
142
+
143
+ err = inflateInit(d_stream)
144
+ CHECK_ERR(err, "inflateInit")
145
+
146
+ while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
147
+ d_stream.avail_in = d_stream.avail_out = 1
148
+ err = inflate(d_stream, Z_NO_FLUSH)
149
+ break if (err == Z_STREAM_END)
150
+ CHECK_ERR(err, "inflate")
151
+ end
152
+
153
+ err = inflateEnd(d_stream)
154
+ CHECK_ERR(err, "inflateEnd")
155
+ uncompr = uncompr[0,d_stream.total_out]
156
+ if uncompr != @@hello
157
+ puts("bad inflate")
158
+ exit(1)
159
+ else
160
+ puts("inflate(): #{uncompr}")
161
+ end
162
+ end
163
+
164
+ def test_large_deflate(compr, comprLen, uncompr, uncomprLen)
165
+ c_stream = Z_stream.new
166
+ err = deflateInit(c_stream, Z_BEST_SPEED)
167
+ CHECK_ERR(err, "deflateInit")
168
+
169
+ c_stream.next_out = Bytef.new(compr)
170
+ c_stream.avail_out = comprLen
171
+ c_stream.next_in = Bytef.new(uncompr)
172
+ c_stream.avail_in = uncomprLen
173
+ err = deflate(c_stream, Z_NO_FLUSH)
174
+ CHECK_ERR(err, "deflate")
175
+ if c_stream.avail_in.nonzero?
176
+ puts("deflate not greedy")
177
+ exit(1)
178
+ end
179
+
180
+ deflateParams(c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY)
181
+ c_stream.next_in = Bytef.new(compr)
182
+ c_stream.avail_in = comprLen/2
183
+ err = deflate(c_stream, Z_NO_FLUSH)
184
+ CHECK_ERR(err, "deflate")
185
+
186
+ deflateParams(c_stream, Z_BEST_COMPRESSION, Z_FILTERED)
187
+ c_stream.next_in = Bytef.new(uncompr)
188
+ c_stream.avail_in = uncomprLen
189
+ err = deflate(c_stream, Z_NO_FLUSH)
190
+ CHECK_ERR(err, "deflate")
191
+
192
+ err = deflate(c_stream, Z_FINISH)
193
+ if (err != Z_STREAM_END)
194
+ puts("deflate should report Z_STREAM_END")
195
+ exit(1)
196
+ end
197
+ err = deflateEnd(c_stream)
198
+ CHECK_ERR(err, "deflateEnd")
199
+ end
200
+
201
+ def test_large_inflate(compr, comprLen, uncompr, uncomprLen)
202
+ d_stream = Z_stream.new
203
+ uncompr[0,7] = "garbage"
204
+
205
+ d_stream.next_in = Bytef.new(compr)
206
+ d_stream.avail_in = comprLen
207
+
208
+ err = inflateInit(d_stream)
209
+ CHECK_ERR(err, "inflateInit")
210
+
211
+ while true
212
+ d_stream.next_out = Bytef.new(uncompr)
213
+ d_stream.avail_out = uncomprLen
214
+ err = inflate(d_stream, Z_NO_FLUSH)
215
+ break if (err == Z_STREAM_END)
216
+ CHECK_ERR(err, "large inflate")
217
+ end
218
+
219
+ err = inflateEnd(d_stream)
220
+ CHECK_ERR(err, "inflateEnd")
221
+
222
+ if (d_stream.total_out != 2*uncomprLen + comprLen/2)
223
+ puts("bad large inflate: #{d_stream.total_out}")
224
+ exit(1)
225
+ else
226
+ puts("large_inflate(): OK")
227
+ end
228
+ end
229
+
230
+ def test_flush(compr, comprLen)
231
+ c_stream = Z_stream.new
232
+ len = @@hello.length
233
+
234
+ err = deflateInit(c_stream, Z_DEFAULT_COMPRESSION)
235
+ CHECK_ERR(err, "deflateInit")
236
+
237
+ c_stream.next_in = Bytef.new(@@hello)
238
+ c_stream.next_out = Bytef.new(compr)
239
+ c_stream.avail_in = 3
240
+ c_stream.avail_out = comprLen
241
+ err = deflate(c_stream, Z_FULL_FLUSH)
242
+ CHECK_ERR(err, "deflate")
243
+
244
+ compr[3]=(compr[3].ord+1).chr
245
+ c_stream.avail_in = len - 3
246
+
247
+ err = deflate(c_stream, Z_FINISH)
248
+ if (err != Z_STREAM_END)
249
+ CHECK_ERR(err, "deflate")
250
+ end
251
+ err = deflateEnd(c_stream)
252
+ CHECK_ERR(err, "deflateEnd")
253
+
254
+ comprLen = c_stream.total_out
255
+ end
256
+
257
+ def test_sync(compr, comprLen, uncompr, uncomprLen)
258
+ d_stream = Z_stream.new
259
+ uncompr[0,7] = "garbage"
260
+
261
+ d_stream.next_in = Bytef.new(compr)
262
+ d_stream.avail_in = 2
263
+
264
+ err = inflateInit(d_stream)
265
+ CHECK_ERR(err, "inflateInit")
266
+
267
+ d_stream.next_out = Bytef.new(uncompr)
268
+ d_stream.avail_out = uncomprLen
269
+
270
+ inflate(d_stream, Z_NO_FLUSH)
271
+ CHECK_ERR(err, "inflate")
272
+
273
+ d_stream.avail_in = comprLen-2
274
+ err = inflateSync(d_stream)
275
+ CHECK_ERR(err, "inflateSync")
276
+
277
+ err = inflate(d_stream, Z_FINISH)
278
+ if (err != Z_DATA_ERROR)
279
+ puts("inflate should report DATA_ERROR")
280
+ exit(1)
281
+ end
282
+ err = inflateEnd(d_stream)
283
+ uncompr = uncompr[0,d_stream.total_out]
284
+ CHECK_ERR(err, "inflateEnd")
285
+ puts("after inflateSync(): hel#{uncompr}")
286
+ end
287
+
288
+ def test_dict_deflate(compr, comprLen)
289
+ c_stream = Z_stream.new
290
+ err = deflateInit(c_stream, Z_BEST_COMPRESSION)
291
+ CHECK_ERR(err, "deflateInit")
292
+
293
+ err = deflateSetDictionary(c_stream,@@dictionary, @@dictionary.length)
294
+ CHECK_ERR(err, "deflateSetDictionary")
295
+
296
+ @@dictId = c_stream.adler
297
+ c_stream.next_out = Bytef.new(compr)
298
+ c_stream.avail_out = comprLen
299
+
300
+ c_stream.next_in = Bytef.new(@@hello)
301
+ c_stream.avail_in = @@hello.length
302
+
303
+ err = deflate(c_stream, Z_FINISH)
304
+ if (err != Z_STREAM_END)
305
+ puts("deflate should report Z_STREAM_END")
306
+ exit(1)
307
+ end
308
+ err = deflateEnd(c_stream)
309
+ CHECK_ERR(err, "deflateEnd")
310
+ end
311
+
312
+ def test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
313
+ d_stream = Z_stream.new
314
+ uncompr[0,7] = "garbage"
315
+
316
+ d_stream.next_in = Bytef.new(compr)
317
+ d_stream.avail_in = comprLen
318
+
319
+ err = inflateInit(d_stream)
320
+ CHECK_ERR(err, "inflateInit")
321
+ d_stream.next_out = Bytef.new(uncompr)
322
+ d_stream.avail_out = uncomprLen
323
+
324
+ while true
325
+ err = inflate(d_stream, Z_NO_FLUSH)
326
+ break if (err == Z_STREAM_END)
327
+ if (err == Z_NEED_DICT)
328
+ if (d_stream.adler != @@dictId)
329
+ puts("unexpected dictionary")
330
+ exit(1)
331
+ end
332
+ err = inflateSetDictionary(d_stream, @@dictionary,@@dictionary.length)
333
+
334
+ end
335
+ CHECK_ERR(err, "inflate with dict")
336
+ end
337
+
338
+ err = inflateEnd(d_stream)
339
+ CHECK_ERR(err, "inflateEnd")
340
+ uncompr = uncompr[0,d_stream.total_out]
341
+ if uncompr != @@hello
342
+ puts("bad inflate with dict")
343
+ exit(1)
344
+ else
345
+ puts("inflate with dictionary: #{uncompr}")
346
+ end
347
+ end
348
+
349
+ comprLen = 10000*4
350
+ uncomprLen = comprLen
351
+ myVersion = ZLIB_VERSION
352
+
353
+ if (zlibVersion[0] != myVersion[0])
354
+ puts("incompatible zlib version")
355
+ exit(1)
356
+ elsif (zlibVersion != ZLIB_VERSION)
357
+ puts("warning: different zlib version")
358
+ end
359
+
360
+ compr = 0.chr * comprLen
361
+ uncompr = 0.chr * uncomprLen
362
+ if (compr.nil? || uncompr.nil?)
363
+ puts("out of memory")
364
+ exit(1)
365
+ end
366
+ test_compress(compr, comprLen, uncompr, uncomprLen)
367
+
368
+ test_gzio((ARGV.length > 0 ? ARGV[0] : TESTFILE),
369
+ uncompr, uncomprLen)
370
+
371
+ test_deflate(compr, comprLen)
372
+ test_inflate(compr, comprLen, uncompr, uncomprLen)
373
+ test_large_deflate(compr, comprLen, uncompr, uncomprLen)
374
+ test_large_inflate(compr, comprLen, uncompr, uncomprLen)
375
+
376
+ test_flush(compr, comprLen)
377
+
378
+ test_sync(compr, comprLen, uncompr, uncomprLen)
379
+ comprLen = uncomprLen
380
+
381
+ test_dict_deflate(compr, comprLen)
382
+ test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
383
+
384
+
385
+