diff options
Diffstat (limited to 'node_modules/browserify-zlib/test/test-zlib.js')
| -rw-r--r-- | node_modules/browserify-zlib/test/test-zlib.js | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/node_modules/browserify-zlib/test/test-zlib.js b/node_modules/browserify-zlib/test/test-zlib.js new file mode 100644 index 000000000..64c02c5dc --- /dev/null +++ b/node_modules/browserify-zlib/test/test-zlib.js @@ -0,0 +1,206 @@ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var assert = require('assert'); +var zlib = require('../'); +var path = require('path'); + +var zlibPairs = + [[zlib.Deflate, zlib.Inflate], + [zlib.Gzip, zlib.Gunzip], + [zlib.Deflate, zlib.Unzip], + [zlib.Gzip, zlib.Unzip], + [zlib.DeflateRaw, zlib.InflateRaw]]; + +// how fast to trickle through the slowstream +var trickle = [128, 1024, 1024 * 1024]; + +// tunable options for zlib classes. + +// several different chunk sizes +var chunkSize = [128, 1024, 1024 * 16, 1024 * 1024]; + +// this is every possible value. +var level = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +var windowBits = [8, 9, 10, 11, 12, 13, 14, 15]; +var memLevel = [1, 2, 3, 4, 5, 6, 7, 8, 9]; +var strategy = [0, 1, 2, 3, 4]; + +// it's nice in theory to test every combination, but it +// takes WAY too long. Maybe a pummel test could do this? +if (!process.env.PUMMEL) { + trickle = [1024]; + chunkSize = [1024 * 16]; + level = [6]; + memLevel = [8]; + windowBits = [15]; + strategy = [0]; +} + +var fs = require('fs'); + +if (process.env.FAST) { + zlibPairs = [[zlib.Gzip, zlib.Unzip]]; +} + +var tests = { + 'person.jpg': fs.readFileSync(__dirname + '/fixtures/person.jpg'), + 'elipses.txt': fs.readFileSync(__dirname + '/fixtures/elipses.txt'), + 'empty.txt': fs.readFileSync(__dirname + '/fixtures/empty.txt') +}; + +var util = require('util'); +var stream = require('stream'); + + +// stream that saves everything +function BufferStream() { + this.chunks = []; + this.length = 0; + this.writable = true; + this.readable = true; +} + +util.inherits(BufferStream, stream.Stream); + +BufferStream.prototype.write = function(c) { + this.chunks.push(c); + this.length += c.length; + return true; +}; + +BufferStream.prototype.end = function(c) { + if (c) this.write(c); + // flatten + var buf = new Buffer(this.length); + var i = 0; + this.chunks.forEach(function(c) { + c.copy(buf, i); + i += c.length; + }); + this.emit('data', buf); + this.emit('end'); + return true; +}; + + +function SlowStream(trickle) { + this.trickle = trickle; + this.offset = 0; + this.readable = this.writable = true; +} + +util.inherits(SlowStream, stream.Stream); + +SlowStream.prototype.write = function() { + throw new Error('not implemented, just call ss.end(chunk)'); +}; + +SlowStream.prototype.pause = function() { + this.paused = true; + this.emit('pause'); +}; + +SlowStream.prototype.resume = function() { + var self = this; + if (self.ended) return; + self.emit('resume'); + if (!self.chunk) return; + self.paused = false; + emit(); + function emit() { + if (self.paused) return; + if (self.offset >= self.length) { + self.ended = true; + return self.emit('end'); + } + var end = Math.min(self.offset + self.trickle, self.length); + var c = self.chunk.slice(self.offset, end); + self.offset += c.length; + self.emit('data', c); + process.nextTick(emit); + } +}; + +SlowStream.prototype.end = function(chunk) { + // walk over the chunk in blocks. + var self = this; + self.chunk = chunk; + self.length = chunk.length; + self.resume(); + return self.ended; +}; + + + +// for each of the files, make sure that compressing and +// decompressing results in the same data, for every combination +// of the options set above. +var tape = require('tape'); + +Object.keys(tests).forEach(function(file) { + var test = tests[file]; + chunkSize.forEach(function(chunkSize) { + trickle.forEach(function(trickle) { + windowBits.forEach(function(windowBits) { + level.forEach(function(level) { + memLevel.forEach(function(memLevel) { + strategy.forEach(function(strategy) { + zlibPairs.forEach(function(pair) { + var Def = pair[0]; + var Inf = pair[1]; + var opts = { + level: level, + windowBits: windowBits, + memLevel: memLevel, + strategy: strategy + }; + + var msg = file + ' ' + + chunkSize + ' ' + + JSON.stringify(opts) + ' ' + + Def.name + ' -> ' + Inf.name; + + tape('zlib ' + msg, function(t) { + t.plan(1); + + var def = new Def(opts); + var inf = new Inf(opts); + var ss = new SlowStream(trickle); + var buf = new BufferStream(); + + // verify that the same exact buffer comes out the other end. + buf.on('data', function(c) { + t.deepEqual(c, test); + }); + + // the magic happens here. + ss.pipe(def).pipe(inf).pipe(buf); + ss.end(test); + }); + }); + }); + }); + }); + }); + }); + }); +}); |