yencode 1.0.8 → 1.1.2

package/test/_speedbase.js

@@ -0,0 +1,147 @@
+// test config (defaults)
+var sz = 768000;
+var rounds = 80;
+var trials = 8;
+var asyncWait = 1000;
+
+var maxSize = require('./_maxsize');
+var decimal = (''+1.1).substr(1, 1);
+var fmtSpeed = function(size, time) {
+	var rate = ('' + (Math.round(100*(size/1048576)/time)/100)).split(decimal);
+	
+	return ('        ' + rate[0]).substr(-8) + decimal + ((rate[1]|0) + '00').substr(0, 2) + ' MiB/s';
+};
+var initBuffers = function() {
+	module.exports.bufWorst = new Buffer(sz);
+	module.exports.bufBest = new Buffer(sz);
+	module.exports.bufAvg = [];
+	module.exports.bufAvg2x = [];
+	module.exports.bufTarget = new Buffer(maxSize(sz));
+
+	module.exports.bufWorst.fill(224);
+	module.exports.bufBest.fill(0);
+	
+	// use cipher as a fast, consistent RNG
+	var cipher = require('crypto').createCipher;
+	[['aes-128-cbc', 'my_incredibly_strong_password'],
+	 ['rc4', 'my_incredibly_strong_password'],
+	 ['aes-128-cbc', '9h8a08b08qpklnac']
+	].forEach(function(cargs) {
+		var rand = cipher.apply(null, cargs);
+		var data = Buffer.concat([rand.update(module.exports.bufBest), rand.final()]).slice(0, sz);
+		module.exports.bufAvg.push(new Buffer(data));
+		
+		// all yEnc special characters exist in range 0-61 (post shift) or 214-19 (pre-shift)
+		// to generate biased data, we'll pack the range down (64-191 will get packed to 192-63)
+		for(var i=0; i<data.length; i++) {
+			if(data[i] >= 64 && data[i] < 192)
+				data[i] = (data[i] + 128) & 0xff;
+		}
+		module.exports.bufAvg2x.push(data);
+	});
+};
+module.exports = {
+	size: sz,
+	rounds: rounds,
+	sleep: 0,
+	avgOnly: false,
+	decMethods: {'clean':true, 'raw':true, 'incr':true, 'rawincr':true},
+	
+	bufWorst: null,
+	bufBest: null,
+	bufAvg: null,
+	bufAvg2x: null,
+	bufTarget: null,
+	
+	bench: function(fn) {
+		var times = Array(trials);
+		for(var trial=0; trial<trials; trial++) {
+			var p=process.hrtime();
+			for(var i=0;i<rounds;i++) fn();
+			var t=process.hrtime(p);
+			
+			times[trial] = t[0] + t[1]/1000000000;
+		}
+		// pick fastest time to try to avoid issues with clockspeed throttling
+		return Math.min.apply(null, times);
+	},
+	_benchAsync: function(fn, cb, trials, results) {
+		var p=process.hrtime();
+		for(var i=0;i<rounds;i++) fn();
+		results.push(process.hrtime(p));
+		
+		if(--trials)
+			setTimeout(module.exports._benchAsync.bind(null, fn, cb, trials, results), asyncWait);
+		else
+			cb(Math.min.apply(null, results));
+	},
+	benchAsync: function(fn, cb) {
+		setTimeout(function() {
+			module.exports._benchAsync(fn, cb, trials, []);
+		}, asyncWait);
+	},
+	run: function(name, fn, sz2) {
+		var time = module.exports.bench(fn);
+		console.log(
+			(name+'                         ').substr(0, 25) + ':'
+			+ fmtSpeed(sz*rounds, time)
+			+ (sz2 ? (' ' + fmtSpeed(sz2*rounds, time)) : '')
+		);
+	},
+	
+	parseArgs: function(helpText) {
+		process.argv.forEach(function(arg) {
+			arg = arg.toLowerCase();
+			if(arg == '-h' || arg == '--help' || arg == '-?') {
+				console.log(helpText + ' [{-z|--size}=bytes('+sz+')] [{-r|--rounds}=num('+rounds+')] [{-t|--trials}=num('+trials+')]');
+				process.exit(0);
+			}
+			if(arg == '-a' || arg == '--average-only') {
+				module.exports.avgOnly = true;
+			}
+			
+			var m = arg.match(/^(-s=?|--sleep=)(\d+)$/);
+			if(m)
+				module.exports.sleep = m[2] |0;
+			
+			m = arg.match(/^(-m=?|--methods=)([a-z,]+)$/);
+			if(m) {
+				var methods = module.exports.decMethods;
+				for(var k in methods)
+					methods[k] = false;
+				var setAMethod = false;
+				m[2].split(',').forEach(function(meth) {
+					if(meth in methods) {
+						setAMethod = true;
+						methods[meth] = true;
+					}
+				});
+				if(!setAMethod) {
+					console.log('No valid method specified');
+					process.exit(1);
+				}
+			}
+			
+			m = arg.match(/^(-t=?|--trials=)(\d+)$/);
+			if(m)
+				trials = m[2] |0;
+			
+			m = arg.match(/^(-r=?|--rounds=)(\d+)$/);
+			if(m) {
+				rounds = m[2] |0;
+				module.exports.rounds = rounds;
+			}
+			
+			m = arg.match(/^(-z=?|--size=)(\d+)$/);
+			if(m) {
+				sz = m[2] |0;
+				module.exports.size = sz;
+				initBuffers();
+			}
+			
+		});
+	}
+	
+};
+
+initBuffers();

package/test/speedcrc.js

@@ -0,0 +1,20 @@
+var y = require('../build/Release/yencode');
+var _ = require('./_speedbase');
+
+
+_.parseArgs('Syntax: node test/speedcrc [{-s|--sleep}=msecs(0)]');
+
+// warmup
+if(!_.sleep) {
+	_.bufAvg.forEach(function(buf, i) {
+		var p=process.hrtime();
+		for(var i=0;i<_.rounds;i+=2) y.crc32(buf);
+		var t=process.hrtime(p);
+	});
+}
+
+setTimeout(function() {
+	_.bufAvg.forEach(function(buf, i) {
+		_.run('Random ('+i+')', y.crc32.bind(null, buf));
+	});
+}, _.sleep);

package/test/speeddec.js

@@ -0,0 +1,92 @@
+var y = require('../build/Release/yencode');
+var _ = require('./_speedbase');
+
+var bufSize = _.bufTarget.length;
+
+var mWorst = new Buffer(bufSize);
+var mAvg = _.bufAvg.map(function() {
+	return new Buffer(bufSize);
+});
+var mAvg2x = _.bufAvg2x.map(function() {
+	return new Buffer(bufSize);
+});
+var mBest = new Buffer(bufSize);
+var mBest2 = new Buffer(_.size);
+mBest2.fill(32);
+
+var lenWorst = y.encodeTo(_.bufWorst, mWorst);
+var lenBest = y.encodeTo(_.bufBest, mBest);
+var lenAvg = Array(_.bufAvg.length);
+var lenAvg2x = Array(_.bufAvg2x.length);
+_.bufAvg.forEach(function(buf, i) {
+	lenAvg[i] = y.encodeTo(buf, mAvg[i]);
+});
+_.bufAvg2x.forEach(function(buf, i) {
+	lenAvg2x[i] = y.encodeTo(buf, mAvg2x[i]);
+});
+
+
+
+_.parseArgs('Syntax: node test/speeddec [-a|--average-only] [{-s|--sleep}=msecs(0)] [{-m|--methods}=clean,raw,rawincr]');
+
+console.log('    Test                     Output rate         Read rate   ');
+
+// warmup
+if(!_.sleep) {
+	mAvg.forEach(function(buf) {
+		var p=process.hrtime();
+		for(var j=0;j<_.rounds;j+=2) y.decodeTo(buf, _.bufTarget);
+		for(var j=0;j<_.rounds;j+=2) y.decodeTo(buf, _.bufTarget, true);
+		for(var j=0;j<_.rounds;j+=2) y.decodeIncr(buf, 0, _.bufTarget);
+		var t=process.hrtime(p);
+	});
+}
+
+setTimeout(function() {
+	if(!_.avgOnly) {
+		if(_.decMethods.clean) {
+			_.run('Clean worst (all escaping)', y.decodeTo.bind(null, mWorst, _.bufTarget), lenWorst);
+			_.run('Clean best (min escaping)',  y.decodeTo.bind(null, mBest, _.bufTarget), lenBest);
+			_.run('Clean pass (no escaping)',  y.decodeTo.bind(null, mBest2, _.bufTarget));
+		}
+		if(_.decMethods.raw) {
+			_.run('Raw worst', y.decodeTo.bind(null, mWorst, _.bufTarget, true), lenWorst);
+			_.run('Raw best',  y.decodeTo.bind(null, mBest, _.bufTarget, true), lenBest);
+			_.run('Raw pass',  y.decodeTo.bind(null, mBest2, _.bufTarget, true));
+		}
+		if(_.decMethods.rawincr) {
+			_.run('Raw-incr worst', y.decodeIncr.bind(null, mWorst, 0, _.bufTarget), lenWorst);
+			_.run('Raw-incr best',  y.decodeIncr.bind(null, mBest, 0, _.bufTarget), lenBest);
+			_.run('Raw-incr pass',  y.decodeIncr.bind(null, mBest2, 0, _.bufTarget));
+		}
+	}
+	
+	if(_.decMethods.clean)
+		mAvg.forEach(function(buf, i) {
+			_.run('Clean random ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget), lenAvg[i]);
+		});
+	if(_.decMethods.raw)
+		mAvg.forEach(function(buf, i) {
+			_.run('Raw random ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget, true), lenAvg[i]);
+		});
+	if(_.decMethods.rawincr) {
+		mAvg.forEach(function(buf, i) {
+			_.run('Raw-incr random ('+i+')',  y.decodeIncr.bind(null, buf, 0, _.bufTarget), lenAvg[i]);
+		});
+	}
+	
+	if(!_.avgOnly) {
+		if(_.decMethods.clean)
+			mAvg2x.forEach(function(buf, i) {
+				_.run('Clean random 2xEsc ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget), lenAvg2x[i]);
+			});
+		if(_.decMethods.raw)
+			mAvg2x.forEach(function(buf, i) {
+				_.run('Raw random 2xEsc ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget, true), lenAvg2x[i]);
+			});
+		if(_.decMethods.rawincr)
+			mAvg2x.forEach(function(buf, i) {
+				_.run('Raw-incr random 2xEsc ('+i+')',  y.decodeIncr.bind(null, buf, 0, _.bufTarget), lenAvg2x[i]);
+			});
+	}
+}, _.sleep);

package/test/speedenc.js

@@ -0,0 +1,44 @@
+var y = require('../build/Release/yencode');
+var _ = require('./_speedbase');
+
+
+_.parseArgs('Syntax: node test/speedenc [-a|--average-only] [{-s|--sleep}=msecs(0)]');
+
+
+console.log('    Test                       Read rate       Output rate   ');
+
+var lenWorst = y.encodeTo(_.bufWorst, _.bufTarget);
+var lenBest = y.encodeTo(_.bufBest, _.bufTarget);
+var lenAvg = Array(_.bufAvg.length);
+var lenAvg2x = Array(_.bufAvg2x.length);
+
+// warmup
+if(!_.sleep) {
+	_.bufAvg.forEach(function(buf, i) {
+		var p=process.hrtime();
+		for(var j=0;j<_.rounds;j+=1) lenAvg[i] = y.encodeTo(buf, _.bufTarget);
+		var t=process.hrtime(p);
+	});
+	_.bufAvg2x.forEach(function(buf, i) {
+		var p=process.hrtime();
+		for(var j=0;j<_.rounds;j+=1) lenAvg2x[i] = y.encodeTo(buf, _.bufTarget);
+		var t=process.hrtime(p);
+	});
+}
+
+setTimeout(function() {
+	if(!_.avgOnly) {
+		_.run('Worst (all escaping)', y.encodeTo.bind(null, _.bufWorst, _.bufTarget), lenWorst);
+		_.run('Best (no escaping)', y.encodeTo.bind(null, _.bufBest, _.bufTarget), lenBest);
+	}
+	
+	_.bufAvg.forEach(function(buf, i) {
+		_.run('Random ('+i+')', y.encodeTo.bind(null, buf, _.bufTarget), lenAvg[i]);
+	});
+	if(!_.avgOnly) {
+		_.bufAvg2x.forEach(function(buf, i) {
+			_.run('Random 2xEsc ('+i+')', y.encodeTo.bind(null, buf, _.bufTarget), lenAvg2x[i]);
+		});
+	}
+
+}, _.sleep);

package/{testcrc.js → test/testcrc.js}

@@ -1,39 +1,53 @@
-// a basic script to test that raw yEnc works as expected
-
-var assert = require('assert');
-var y = require('./build/Release/yencode.node');
-var crc32 = require('buffer-crc32'); // reference implementation
-
-var ycrc32 = function(s) {
-	return y.crc32(Buffer(s));
-};
-var doTest = function(msg, f, test, expected) {
-	if(!Array.isArray(test)) test = [test];
-	test[0] = Buffer(test[0]);
-	if(!expected && test.length == 1 && f == 'crc32') expected = crc32(test[0]).toString('hex');
-	else if(Buffer.isBuffer(expected)) expected = expected.toString('hex');
-	assert.equal(y[f].apply(null, test).toString('hex'), expected, msg);
-};
-
-
-doTest('Empty test', 'crc32', '');
-doTest('Single char', 'crc32', 'z');
-doTest('Simple string', 'crc32', 'aabbcc');
-doTest('Join', 'crc32', ['cc', ycrc32('aabb')], crc32('aabbcc'));
-doTest('Combine', 'crc32_combine', [ycrc32('aabb'), crc32('cc'), 2], crc32('aabbcc'));
-doTest('Join 2', 'crc32', ['789012', ycrc32('123456')], crc32('123456789012'));
-doTest('Combine 2', 'crc32_combine', [ycrc32('123456'), crc32('789012'), 6], crc32('123456789012'));
-
-doTest('Join Empty', 'crc32', ['', ycrc32('z')], crc32('z'));
-doTest('Join Empty 2', 'crc32', ['z', ycrc32('')], crc32('z'));
-doTest('Join Empty 3', 'crc32', ['', ycrc32('')], crc32(''));
-doTest('Combine Empty', 'crc32_combine', [ycrc32(''), ycrc32('z'), 1], crc32('z'));
-doTest('Combine Empty 2', 'crc32_combine', [ycrc32('z'), ycrc32(''), 0], crc32('z'));
-doTest('Combine Empty 3', 'crc32_combine', [ycrc32(''), ycrc32(''), 0], crc32(''));
-
-assert.equal(y.crc32_zeroes(0).toString('hex'), '00000000', 'Zeroes (0)');
-assert.equal(y.crc32_zeroes(1).toString('hex'), 'd202ef8d', 'Zeroes (1)');
-assert.equal(y.crc32_zeroes(4).toString('hex'), '2144df1c', 'Zeroes (4)');
-
-
-console.log('All tests passed');
+// a basic script to test that raw yEnc works as expected
+
+var assert = require('assert');
+var y = (function() {
+	try {
+		return require('../build/Debug/yencode.node');
+	} catch(x) {}
+	return require('../build/Release/yencode.node');
+})();
+var crc32 = require('buffer-crc32'); // reference implementation
+
+var ycrc32 = function(s) {
+	return y.crc32(Buffer(s));
+};
+var doTest = function(msg, f, test, expected) {
+	if(!Array.isArray(test)) test = [test];
+	test[0] = Buffer(test[0]);
+	if(!expected && test.length == 1 && f == 'crc32') expected = crc32(test[0]).toString('hex');
+	else if(Buffer.isBuffer(expected)) expected = expected.toString('hex');
+	assert.equal(y[f].apply(null, test).toString('hex'), expected, msg);
+};
+
+
+doTest('Empty test', 'crc32', '');
+doTest('Single char', 'crc32', 'z');
+doTest('Simple string', 'crc32', 'aabbcc');
+doTest('Join', 'crc32', ['cc', ycrc32('aabb')], crc32('aabbcc'));
+doTest('Combine', 'crc32_combine', [ycrc32('aabb'), crc32('cc'), 2], crc32('aabbcc'));
+doTest('Join 2', 'crc32', ['789012', ycrc32('123456')], crc32('123456789012'));
+doTest('Combine 2', 'crc32_combine', [ycrc32('123456'), crc32('789012'), 6], crc32('123456789012'));
+
+doTest('Join Empty', 'crc32', ['', ycrc32('z')], crc32('z'));
+doTest('Join Empty 2', 'crc32', ['z', ycrc32('')], crc32('z'));
+doTest('Join Empty 3', 'crc32', ['', ycrc32('')], crc32(''));
+doTest('Combine Empty', 'crc32_combine', [ycrc32(''), ycrc32('z'), 1], crc32('z'));
+doTest('Combine Empty 2', 'crc32_combine', [ycrc32('z'), ycrc32(''), 0], crc32('z'));
+doTest('Combine Empty 3', 'crc32_combine', [ycrc32(''), ycrc32(''), 0], crc32(''));
+
+assert.equal(y.crc32_zeroes(0).toString('hex'), '00000000', 'Zeroes (0)');
+assert.equal(y.crc32_zeroes(1).toString('hex'), 'd202ef8d', 'Zeroes (1)');
+assert.equal(y.crc32_zeroes(4).toString('hex'), '2144df1c', 'Zeroes (4)');
+
+assert.equal(y.crc32_zeroes(0, ycrc32('')).toString('hex'), '00000000', 'Zeroes-Join (0)');
+assert.equal(y.crc32_zeroes(1, ycrc32('')).toString('hex'), 'd202ef8d', 'Zeroes-Join (1)');
+assert.equal(y.crc32_zeroes(0, ycrc32('z')).toString('hex'), crc32('z').toString('hex'), 'Zeroes Empty Join');
+assert.equal(y.crc32_zeroes(4, ycrc32('z')).toString('hex'), crc32('z\u0000\u0000\u0000\u0000').toString('hex'), 'Zeroes (4) Join');
+
+
+doTest('Random', 'crc32', 'fj[-oqijnw34-59n26 4345j8yn89032q78t9ab9gabh023quhoiBO Z GEB780a sdasdq2345673-98hq2-9348h-na9we8zdfgh-n9  8qwhn-098');
+doTest('Random Continue', 'crc32', ['KZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohnSzvHY4DjpxXmyfWYJQoJ7tKdNhGcuRVUzrgXM', ycrc32('BdenbmoBgiB10ZkeUBjrsZV3dg2Da2fhHqU9TMdi69AHhLRck3Nk60YuFBXh6lvtefBpjdTxbeEmsaEm')], crc32('BdenbmoBgiB10ZkeUBjrsZV3dg2Da2fhHqU9TMdi69AHhLRck3Nk60YuFBXh6lvtefBpjdTxbeEmsaEmKZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohnSzvHY4DjpxXmyfWYJQoJ7tKdNhGcuRVUzrgXM'));
+
+
+console.log('All tests passed');

package/test/testdec.js

@@ -0,0 +1,183 @@
+// a basic script to test that raw yEnc works as expected
+
+var assert = require('assert');
+var y = (function() {
+	try {
+		return require('../build/Debug/yencode.node');
+	} catch(x) {}
+	return require('../build/Release/yencode.node');
+})();
+
+var ord = function(c) {
+	return c.charCodeAt(0);
+}, chr = String.fromCharCode;
+// slow reference yEnc implementation
+var refYDec = function(src, findEnd) {
+	var ret = [];
+	if(findEnd && chr(src[0]) == '=' && chr(src[1]) == 'y') return new Buffer(0);
+	for (var i = 0; i < src.length; i++) {
+		switch(chr(src[i])) {
+			case '\r':
+				if(findEnd && chr(src[i+1]) == '\n' && chr(src[i+2]) == '=' && chr(src[i+3]) == 'y')
+					return new Buffer(ret);
+			case '\n': continue;
+			case '=':
+				i++;
+				if(i < src.length)
+					ret.push((src[i] - 42 - 64) & 0xFF);
+				if(chr(src[i]) == '\r') i--;
+				continue;
+		}
+		ret.push((src[i] - 42) & 0xFF);
+	}
+	return new Buffer(ret);
+};
+var refYDecRaw = function(src, findEnd) {
+	// undo NNTP layer
+	var data = [];
+	var i = 0;
+	if(src[0] == ord('.')) {
+		i++;
+		if(findEnd && src[1] == ord('\r') && src[2] == ord('\n'))
+			return new Buffer(0);
+	}
+	// TODO: do leading/trailing spaces/tabs need to be trimmed?
+	for(; i<src.length; i++) {
+		if(src[i] == ord('\r') && src[i+1] == ord('\n') && src[i+2] == ord('.')) {
+			data.push(src[i], src[i+1]);
+			if(findEnd && src[i+3] == ord('\r') && src[i+4] == ord('\n')) {
+				// it's a little vague how this is exactly handled, but we'll push a \r\n to the yenc decoder (above line)
+				// doing so means that =\r\n.\r\n will generate a single escaped character
+				break;
+			}
+			i += 2;
+			continue;
+		}
+		data.push(src[i]);
+	}
+	
+	return refYDec(data, findEnd);
+};
+var testFuncs = [
+	{l: 'nntp', r: refYDecRaw, a: function(s) {
+		return y.decode(s, true);
+	}},
+	{l: 'plain', r: refYDec, a: y.decode},
+	{l: 'nntp-end', r: function(s) {
+		return refYDecRaw(s, true);
+	}, a: function(s) {
+		if(!s.length) return Buffer(0);
+		return y.decodeIncr(s).output;
+	}}
+];
+var doTest = function(msg, data, expected) {
+	data = new Buffer(data);
+	
+	var prepad = 48, postpad = 48;
+	if(data.length > 1024) {
+		prepad = 1;
+		postpad = 1;
+	}
+	
+	for(var i=0; i<prepad; i++) {
+		var pre = new Buffer(i);
+		pre.fill(1);
+		for(var j=0; j<postpad; j++) {
+			testFuncs.forEach(function(f) {
+				var post = new Buffer(j);
+				post.fill(1);
+				
+				var testData = Buffer.concat([pre, data, post]);
+				var x;
+				if(expected === undefined) x = f.r(testData).toString('hex');
+				else x = new Buffer(expected).toString('hex').replace(/ /g, '');
+				var actual = f.a(testData).toString('hex');
+				if(actual != x) {
+					console.log('Actual:', actual);
+					console.log('Expect:', x);
+					console.log('Source:', data.toString('hex'));
+					assert.equal(actual, x, msg + ' [' + i + '/' + j + ' ' + f.l + ']');
+				}
+			});
+			if(expected !== undefined) return; // if given expected string, only do one test
+			
+			// TODO: test various states
+		}
+	}
+};
+
+
+doTest('Empty test', [], '');
+doTest('Simple test', [0,1,2,10,3,61,64]);
+doTest('Just newline', [10], '');
+doTest('Just equals', [61], '');
+doTest('Equal+newline', [61, 13], [163]);
+doTest('Equal+equal', [61, 61], [211]);
+doTest('Equal+equal+newline', [61, 61, 13], [211]);
+doTest('Newline, equal', [10, 61], '');
+doTest('Stripped dot', [13, 10, 46]);
+doTest('Just dot', [46]);
+doTest('Consecutive stripped dot', [13, 10, 46, 13, 10, 46]);
+doTest('Bad escape stripped dot', [61, 13, 10, 46]);
+
+doTest('NNTP end sequence', '\r\n.\r\n');
+doTest('NNTP end sequence (2)', '.\r\n');
+doTest('Yenc end sequence', '\r\n=y');
+doTest('Yenc end sequence (2)', '=y');
+doTest('Mixed end sequence', '\r\n=y\r\n.\r\n');
+doTest('Mixed end sequence (2)', '\r\n.\r\n=y');
+doTest('Not end sequence', '\r\n=abc');
+doTest('Dot stuffed end sequence', '\r\n.=y');
+doTest('Dot stuffed bad escape sequence', '\r\n.=.');
+doTest('Broken end sequence', '\r\n.\ra\n');
+doTest('NNTP end sequence, badly dot stuffed', '\r\n..\r\n');
+doTest('NNTP end sequence, badly dot stuffed (2)', '\r\n.a=y');
+doTest('Bad escape, NNTP end sequence', '=\r\n.\r\n');
+doTest('Bad escape, Yenc end sequence', '=\r\n=y');
+
+
+// longer tests
+var b = new Buffer(256);
+b.fill(0);
+doTest('Long no escaping', b);
+b.fill('='.charCodeAt(0));
+doTest('Long all equals', b);
+for(var i=1; i<b.length; i+=2)
+	b[i] = 64;
+doTest('Long all escaped nulls', b);
+b.fill('='.charCodeAt(0));
+for(var i=0; i<b.length; i+=2)
+	b[i] = 64;
+doTest('Long all invalid escaped nulls', b);
+b.fill(10);
+doTest('Long all newlines', b);
+b.fill(223);
+doTest('Long all tabs', b);
+
+// test for past bug in ARMv8 NEON decoder where nextMask wasn't properly compensated for
+doTest('Extra null issue', new Buffer('2e900a4fb6054c9126171cdc196dc41237bb1b76da9191aa5e85c1d2a2a5c638fe39054a210e8c799473cd510541fd118f3904b242a9938558c879238aae1d3bdab32e287cedb820b494f54ffae6dd0b13f73a4a9499df486a7845c612182bcef72a6e50a8e98351c35765d26c605115dc8c5c56a5e3f20ae6da8dcd78536e6d1601eb1fc3ddc774', 'hex'));
+// end detection bug
+doTest('End detect', new Buffer('612e6161610d610d612e793d3d0d0d2e612e2e0a0d0d61792e3d3d61612e0d0a2e0d2e0a0d79612e0a3d2e2e793d2e610a0d0a0a2e793d790d612e61612e0a3d792e2e3d2e7961793d792e0a61790a0d0a2e0d0a3d0a0d0d0d0a610a0a6161792e3d2e0a2e0d0d0d613d610a0a0a793d613d3d0a3d790d3d0a0a2e2e7979796179613d0d2e792e793d3d61792e612e2e2e793d616161790d0d2e0d0d793d0d790a0a3d0d617979790d2e0d792e612e610a0a0a0a0a79790d0a610d612e0d0a0d3d0a61792e2e0a790d0d792e790d0a2e79612e3d0a79790a0d0d3d0a0a0d3d0a7961610a2e613d792e0a612e613d610a2e0a0a79613d2e2e0d3d3d2e793d792e792e0d0d610d2e2e0d2e79610d2e790d790d3d2e3d790a0a0d0a0a0a612e2e79612e0d2e3d793d2e0a2e3d790a2e3d792e2e610d3d2e0d3d3d0a3d2e0d613d2e0d61610a3d0a2e0a0a3d3d612e3d790d6161613d3d612e3d0d0a2e0d0d0d616179790a2e3d610d612e0d2e3d0d0a3d610d0d61610a7961613d2e790d613d610a3d612e0a2e0d79790d0a610a2e2e0a2e612e2e0d792e61610a2e0d610d3d0a793d613d0d3d0a3d0d0a613d2e0a3d610a3d0d793d0d7979792e3d613d0a2e61610d793d2e0a0a2e612e0d2e2e792e0d2e613d0d790a0d2e610d2e0a2e61793d0d0d0a0a0d0d2e2e0d2e793d3d79612e0a610a610a0d610d0d2e2e790', 'hex'));
+
+// random tests
+for(var i=0; i<32; i++) {
+	var rand = require('crypto').pseudoRandomBytes(128*1024);
+	doTest('Random', rand);
+}
+
+// targeted random tests
+var charset = '=\r\n.ay';
+var randStr = function(n) {
+	var ret = new Buffer(n);
+	for(var i=0; i<n; i++)
+		ret[i] = ord(charset[(Math.random() * charset.length) | 0]);
+	return ret;
+};
+for(var i=0; i<128; i++) {
+	var rand = randStr(2048);
+	doTest('Random2', rand);
+}
+
+
+
+console.log('All tests passed');