bramqp - npm Package Compare versions

bramqp

Package Overview

Dependencies

Maintainers

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 0.1.13 to 0.1.14

.gitignore

test/queue-test.js

lib/connectionHandle.js

		@@ -137,3 +137,3 @@ var util = require('util');
		var self = this;


		var args = Array.prototype.slice.call(arguments);
		@@ -145,3 +145,3 @@ var username = 'guest';
		var callback;


		if (args.length && typeof args[args.length - 1] === 'function') {
		@@ -162,3 +162,3 @@ callback = args.pop();
		}


		async.series([
		@@ -283,3 +283,3 @@ function(seriesCallback) {
		} else {
		return callback(new Error("content must be of type string or buffer"));
		return callback(new Error('content must be of type string or buffer'));
		}
		@@ -286,0 +286,0 @@

lib/specification.js

		@@ -10,3 +10,3 @@ var fs = require('fs');

		var rootPath = path.normalize(__dirname + "/..");
		var rootPath = path.normalize(__dirname + '/..');

		@@ -16,5 +16,8 @@ var specification;

		// TODO remove this hack and do multi spec correctly
		var specRead = '';

		exports.getSpecification = function(callback) {
		if (specification === undefined) {
		specEmitter.on("spec-ready", function() {
		specEmitter.on('spec-ready', function() {
		callback(specification);
		@@ -50,22 +53,31 @@ });
		exports.selectSpecification = function(specPath, callback) {
		var fullSpecPath = rootPath + '/specification/' + specPath + ".xml";
		fs.readFile(fullSpecPath, function(error, data) {
		if (error) {
		return callback(error);
		if (specRead) {
		if (specPath === specRead) {
		callback();
		} else {
		callback('bramqp does not support loading different specs at the same time');
		}
		if (!data \|\| data.length == 0) {
		return callback(new Error("No data in specification file"));
		}
		xml2jsParser.parseString(data, function(err, result) {
		if (err) {
		return callback(err);
		} else {
		var fullSpecPath = rootPath + '/specification/' + specPath + '.xml';
		fs.readFile(fullSpecPath, function(error, data) {
		if (error) {
		return callback(error);
		}
		specification = {};
		specification.path = specPath;
		specification.amqp = liftProperties(result.amqp);
		specification.valueTypes = valueTypes[specPath];
		specEmitter.emit("spec-ready");
		callback();
		if (!data \|\| data.length == 0) {
		return callback(new Error('No data in specification file'));
		}
		xml2jsParser.parseString(data, function(err, result) {
		if (err) {
		return callback(err);
		}
		specification = {};
		specification.path = specPath;
		specification.amqp = liftProperties(result.amqp);
		specification.valueTypes = valueTypes[specPath];
		specEmitter.emit('spec-ready');
		specRead = specPath;
		callback();
		});
		});
		});
		}
		};

package.json

		{
		"name" : "bramqp",
		"version" : "0.1.13",
		"version" : "0.1.14",
		"description" : "bakkerthehacker's rad AMQP library",
		@@ -23,3 +23,3 @@ "keywords" : [ "amqp", "bramqp" ],
		"dependencies" : {
		"async" : "~0.7.0",
		"async" : "~0.9.0",
		"xml2js" : "~0.4.1",
		@@ -26,0 +26,0 @@ "buffer-more-ints" : "~0.0.2"

1595

test/frameParser-test.js

		@@ -11,803 +11,802 @@ var vows = require('vows');

		vows.describe('frameParser').addBatch(
		{
		'The AMQP 0-9-1-extended' : {
		topic : function() {
		var self = this;
		specification.selectSpecification('rabbitmq/full/amqp0-9-1.stripped.extended', function() {
		specification.getSpecification(function(spec) {
		self.callback(null, new FrameParser(spec));
		});
		});
		},
		'Octet parser' : {
		topic : function(parser) {
		return parser.parseOctet.bind(parser);
		},
		'should parse 0x03' : function(parse) {
		var buffer = new Buffer([ 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 255);
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Signed Octet parser' : {
		topic : function(parser) {
		return parser.parseSignedOctet.bind(parser);
		},
		'should parse 0x03' : function(parse) {
		var buffer = new Buffer([ 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Short parser' : {
		topic : function(parser) {
		return parser.parseShort.bind(parser);
		},
		'should parse 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x03, 0x63' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 867);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 65535);
		assert.strictEqual(buffer.read, 2);
		}
		},
		'Signed Short parser' : {
		topic : function(parser) {
		return parser.parseSignedShort.bind(parser);
		},
		'should parse 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x03, 0x63' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 867);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 2);
		}
		},
		'Long parser' : {
		topic : function(parser) {
		return parser.parseLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 56877370);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 4294967295);
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Signed Long parser' : {
		topic : function(parser) {
		return parser.parseSignedLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0xff, 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 56877370);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Long Long parser' : {
		// NOTICE!!
		// These tests may still pass for different values,
		// due to
		// javascript having a maximum integer size of 2^53
		topic : function(parser) {
		return parser.parseLongLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 244286446867952679);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 18446744073709551615);
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Signed Long Long parser' : {
		// NOTICE!!
		// These tests may still pass for different values,
		// due to
		// javascript having a maximum integer size of 2^53
		topic : function(parser) {
		return parser.parseSignedLongLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 244286446867952679);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Boolean parser' : {
		topic : function(parser) {
		return parser.parseBoolean.bind(parser);
		},
		'should parse 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isFalse(value);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0x01' : function(parse) {
		var buffer = new Buffer([ 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isTrue(value);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isTrue(value);
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Float parser' : {
		topic : function(parser) {
		return parser.parseFloat.bind(parser);
		},
		'should parse 0x3f, 0x80, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0x80, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xc0, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xc0, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -2);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x7f, 0x7f, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0x7f, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3.4028234663852886e+38);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x80, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x80, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -0);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x7f, 0x80, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0x80, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, Infinity);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0x80, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xff, 0x80, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -Infinity);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x7f, 0x80, 0x00, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0x80, 0x00, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isNaN(value);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x3e, 0xaa, 0xaa, 0xab' : function(parse) {
		var buffer = new Buffer([ 0x3e, 0xaa, 0xaa, 0xab ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0.3333333432674408);
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Double parser' : {
		topic : function(parser) {
		return parser.parseDouble.bind(parser);
		},
		'should parse 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1.0000000000000002);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1.0000000000000004);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 2);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -2);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -0);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, Infinity);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -Infinity);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isNaN(value);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0.3333333333333333);
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Bit Pack parser' : {
		topic : function(parser) {
		return parser.parseBitPack.bind(parser);
		},
		'should parse 0x00 (8)' : function(parse) {
		var buffer = new Buffer([ 0x00 ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 8; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ false, false, false, false, false, false, false, false ]);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff (8)' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 8; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, true, true, true, true, true, true ]);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xab (8)' : function(parse) {
		var buffer = new Buffer([ 0xab ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 8; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, false, true, false, true, false, true ]);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xab, 0xab (10)' : function(parse) {
		var buffer = new Buffer([ 0xab, 0xab ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 10; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, false, true, false, true, false, true, true, true ]);
		assert.strictEqual(buffer.read, 2);
		},
		vows.describe('frameParser').addBatch({
		'The AMQP 0-9-1-extended' : {
		topic : function() {
		var self = this;
		specification.selectSpecification('rabbitmq/full/amqp0-9-1.stripped.extended', function() {
		specification.getSpecification(function(spec) {
		self.callback(null, new FrameParser(spec));
		});
		});
		},
		'Octet parser' : {
		topic : function(parser) {
		return parser.parseOctet.bind(parser);
		},
		'should parse 0x03' : function(parse) {
		var buffer = new Buffer([ 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 255);
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Signed Octet parser' : {
		topic : function(parser) {
		return parser.parseSignedOctet.bind(parser);
		},
		'should parse 0x03' : function(parse) {
		var buffer = new Buffer([ 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Short parser' : {
		topic : function(parser) {
		return parser.parseShort.bind(parser);
		},
		'should parse 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x03, 0x63' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 867);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 65535);
		assert.strictEqual(buffer.read, 2);
		}
		},
		'Signed Short parser' : {
		topic : function(parser) {
		return parser.parseSignedShort.bind(parser);
		},
		'should parse 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x03, 0x63' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 867);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 2);
		}
		},
		'Long parser' : {
		topic : function(parser) {
		return parser.parseLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 56877370);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 4294967295);
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Signed Long parser' : {
		topic : function(parser) {
		return parser.parseSignedLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0xff, 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 56877370);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Long Long parser' : {
		// NOTICE!!
		// These tests may still pass for different values,
		// due to
		// javascript having a maximum integer size of 2^53
		topic : function(parser) {
		return parser.parseLongLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 244286446867952679);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 18446744073709551615);
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Signed Long Long parser' : {
		// NOTICE!!
		// These tests may still pass for different values,
		// due to
		// javascript having a maximum integer size of 2^53
		topic : function(parser) {
		return parser.parseSignedLongLong.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -3);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27' : function(parse) {
		var buffer = new Buffer([ 0x03, 0x63, 0xe1, 0x3a, 0xa9, 0x01, 0xb4, 0x27 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 244286446867952679);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -1);
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Boolean parser' : {
		topic : function(parser) {
		return parser.parseBoolean.bind(parser);
		},
		'should parse 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isFalse(value);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0x01' : function(parse) {
		var buffer = new Buffer([ 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isTrue(value);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isTrue(value);
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Float parser' : {
		topic : function(parser) {
		return parser.parseFloat.bind(parser);
		},
		'should parse 0x3f, 0x80, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0x80, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xc0, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xc0, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -2);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x7f, 0x7f, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0x7f, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3.4028234663852886e+38);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x80, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x80, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -0);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x7f, 0x80, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0x80, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, Infinity);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0xff, 0x80, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xff, 0x80, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -Infinity);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x7f, 0x80, 0x00, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0x80, 0x00, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isNaN(value);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x3e, 0xaa, 0xaa, 0xab' : function(parse) {
		var buffer = new Buffer([ 0x3e, 0xaa, 0xaa, 0xab ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0.3333333432674408);
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Double parser' : {
		topic : function(parser) {
		return parser.parseDouble.bind(parser);
		},
		'should parse 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1.0000000000000002);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 1.0000000000000004);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 2);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -2);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -0);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, Infinity);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -Infinity);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isNaN(value);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55' : function(parse) {
		var buffer = new Buffer([ 0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0.3333333333333333);
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Bit Pack parser' : {
		topic : function(parser) {
		return parser.parseBitPack.bind(parser);
		},
		'should parse 0x00 (8)' : function(parse) {
		var buffer = new Buffer([ 0x00 ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 8; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ false, false, false, false, false, false, false, false ]);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xff (8)' : function(parse) {
		var buffer = new Buffer([ 0xff ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 8; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, true, true, true, true, true, true ]);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xab (8)' : function(parse) {
		var buffer = new Buffer([ 0xab ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 8; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, false, true, false, true, false, true ]);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0xab, 0xab (10)' : function(parse) {
		var buffer = new Buffer([ 0xab, 0xab ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 10; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, false, true, false, true, false, true, true, true ]);
		assert.strictEqual(buffer.read, 2);
		},

		'should parse 0xab, 0xab (16)' : function(parse) {
		var buffer = new Buffer([ 0xab, 0xab ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 16; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, false, true, false, true, false, true, true, true, false,
		true, false, true, false, true ]);
		assert.strictEqual(buffer.read, 2);
		}
		},
		'Decimal parser' : {
		topic : function(parser) {
		return parser.parseDecimal.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x02, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x02, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0.03);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x02, 0xff, 0xff, 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0x02, 0xff, 0xff, 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -0.03);
		assert.strictEqual(buffer.read, 5);
		}
		},
		'Timestamp parser' : {
		topic : function(parser) {
		return parser.parseTimestamp.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Thu, 01 Jan 1970 00:00:00 GMT').getTime());
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Wed, 31 Dec 1969 23:59:59 GMT').getTime());
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Thu, 14 Nov 2013 19:32:57 GMT').getTime());
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Short String parser' : {
		topic : function(parser) {
		return parser.parseShortString.bind(parser);
		},
		'should parse 0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21' : function(parse) {
		var buffer = new Buffer([ 0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c,
		0x64, 0x21 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 'Hello World!');
		assert.strictEqual(buffer.read, 13);
		},
		'should parse 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, '');
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Long String parser' : {
		topic : function(parser) {
		return parser.parseLongString.bind(parser);
		},
		'should parse 0x00, 0x00, 0x01, 0xf5, ...' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x01, 0xf5, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x69,
		0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x74,
		0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x74,
		0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69, 0x73, 0x63, 0x69, 0x6e,
		0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e, 0x20, 0x50, 0x65, 0x6c, 0x6c, 0x65, 0x6e,
		0x74, 0x65, 0x73, 0x71, 0x75, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x74, 0x69, 0x73, 0x20,
		0x73, 0x6f, 0x6c, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x75, 0x64, 0x69, 0x6e, 0x20, 0x6e,
		0x69, 0x62, 0x68, 0x20, 0x76, 0x65, 0x6c, 0x20, 0x74, 0x69, 0x6e, 0x63, 0x69, 0x64,
		0x75, 0x6e, 0x74, 0x2e, 0x20, 0x4e, 0x75, 0x6e, 0x63, 0x20, 0x61, 0x74, 0x20, 0x6e,
		0x75, 0x6e, 0x63, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x71, 0x75, 0x61, 0x74, 0x2c,
		0x20, 0x72, 0x75, 0x74, 0x72, 0x75, 0x6d, 0x20, 0x70, 0x75, 0x72, 0x75, 0x73, 0x20,
		0x69, 0x6e, 0x2c, 0x20, 0x76, 0x65, 0x6e, 0x65, 0x6e, 0x61, 0x74, 0x69, 0x73, 0x20,
		0x72, 0x69, 0x73, 0x75, 0x73, 0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x6c,
		0x69, 0x62, 0x65, 0x72, 0x6f, 0x20, 0x6c, 0x6f, 0x72, 0x65, 0x6d, 0x2c, 0x20, 0x74,
		0x69, 0x6e, 0x63, 0x69, 0x64, 0x75, 0x6e, 0x74, 0x20, 0x76, 0x65, 0x6c, 0x20, 0x6c,
		0x65, 0x6f, 0x20, 0x65, 0x67, 0x65, 0x74, 0x2c, 0x20, 0x66, 0x65, 0x72, 0x6d, 0x65,
		0x6e, 0x74, 0x75, 0x6d, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6d, 0x73, 0x61, 0x6e, 0x20,
		0x72, 0x69, 0x73, 0x75, 0x73, 0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x6d,
		0x61, 0x75, 0x72, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x75, 0x72, 0x69, 0x73, 0x2c, 0x20,
		0x65, 0x6c, 0x65, 0x69, 0x66, 0x65, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x6c, 0x65,
		0x6f, 0x20, 0x73, 0x65, 0x64, 0x2c, 0x20, 0x76, 0x65, 0x73, 0x74, 0x69, 0x62, 0x75,
		0x6c, 0x75, 0x6d, 0x20, 0x64, 0x69, 0x63, 0x74, 0x75, 0x6d, 0x20, 0x61, 0x6e, 0x74,
		0x65, 0x2e, 0x20, 0x56, 0x69, 0x76, 0x61, 0x6d, 0x75, 0x73, 0x20, 0x62, 0x69, 0x62,
		0x65, 0x6e, 0x64, 0x75, 0x6d, 0x20, 0x76, 0x65, 0x6e, 0x65, 0x6e, 0x61, 0x74, 0x69,
		0x73, 0x20, 0x6e, 0x69, 0x73, 0x69, 0x20, 0x75, 0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d,
		0x65, 0x6e, 0x74, 0x75, 0x6d, 0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x75,
		0x6c, 0x74, 0x72, 0x69, 0x63, 0x69, 0x65, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
		0x64, 0x6f, 0x20, 0x6c, 0x61, 0x6f, 0x72, 0x65, 0x65, 0x74, 0x2e, 0x20, 0x4d, 0x61,
		0x65, 0x63, 0x65, 0x6e, 0x61, 0x73, 0x20, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x73,
		0x69, 0x73, 0x20, 0x6e, 0x75, 0x6e, 0x63, 0x20, 0x61, 0x74, 0x20, 0x70, 0x72, 0x65,
		0x74, 0x69, 0x75, 0x6d, 0x20, 0x74, 0x72, 0x69, 0x73, 0x74, 0x69, 0x71, 0x75, 0x65,
		0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x20, 0x6c,
		0x65, 0x63, 0x74, 0x75, 0x73, 0x2c, 0x20, 0x64, 0x69, 0x63, 0x74, 0x75, 0x6d, 0x20,
		0x69, 0x64, 0x20, 0x66, 0x65, 0x6c, 0x69, 0x73, 0x20, 0x61, 0x63, 0x2c, 0x20, 0x6c,
		0x61, 0x63, 0x69, 0x6e, 0x69, 0x61, 0x20, 0x74, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x75,
		0x6e, 0x74, 0x20, 0x65, 0x72, 0x61, 0x74, 0x20, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x70,
		0x61, 0x74, 0x2e, 0x20 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 'Lorem ipsum dolor sit amet, consectetur '
		+ 'adipiscing elit. Pellentesque mattis sollicitudin nibh vel tincidunt. '
		+ 'Nunc at nunc consequat, rutrum purus in, venenatis risus. Donec libero '
		+ 'lorem, tincidunt vel leo eget, fermentum accumsan risus. Donec mauris '
		+ 'mauris, eleifend in leo sed, vestibulum dictum ante. Vivamus bibendum '
		+ 'venenatis nisi ut elementum. Donec ultricies commodo laoreet. Maecenas '
		+ 'facilisis nunc at pretium tristique. Donec elit lectus, dictum id felis '
		+ 'ac, lacinia tincidunt erat volutpat. ');
		assert.strictEqual(buffer.read, 505);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, '');
		assert.strictEqual(buffer.read, 4);
		}
		'should parse 0xab, 0xab (16)' : function(parse) {
		var buffer = new Buffer([ 0xab, 0xab ]);
		buffer.read = 0;
		var value = [];
		for (var i = 0; i < 16; i++) {
		value[i] = parse(buffer, i);
		}
		assert.deepEqual(value, [ true, true, false, true, false, true, false, true, true, true, false,
		true, false, true, false, true ]);
		assert.strictEqual(buffer.read, 2);
		}
		},
		'Decimal parser' : {
		topic : function(parser) {
		return parser.parseDecimal.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x02, 0x00, 0x00, 0x00, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x02, 0x00, 0x00, 0x00, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 0.03);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x02, 0xff, 0xff, 0xff, 0xfd' : function(parse) {
		var buffer = new Buffer([ 0x02, 0xff, 0xff, 0xff, 0xfd ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -0.03);
		assert.strictEqual(buffer.read, 5);
		}
		},
		'Timestamp parser' : {
		topic : function(parser) {
		return parser.parseTimestamp.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Thu, 01 Jan 1970 00:00:00 GMT').getTime());
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff' : function(parse) {
		var buffer = new Buffer([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Wed, 31 Dec 1969 23:59:59 GMT').getTime());
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Thu, 14 Nov 2013 19:32:57 GMT').getTime());
		assert.strictEqual(buffer.read, 8);
		}
		},
		'Short String parser' : {
		topic : function(parser) {
		return parser.parseShortString.bind(parser);
		},
		'should parse 0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21' : function(parse) {
		var buffer = new Buffer([ 0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c,
		0x64, 0x21 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 'Hello World!');
		assert.strictEqual(buffer.read, 13);
		},
		'should parse 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, '');
		assert.strictEqual(buffer.read, 1);
		}
		},
		'Long String parser' : {
		topic : function(parser) {
		return parser.parseLongString.bind(parser);
		},
		'should parse 0x00, 0x00, 0x01, 0xf5, ...' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x01, 0xf5, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x69,
		0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x74,
		0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x74,
		0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69, 0x73, 0x63, 0x69, 0x6e,
		0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e, 0x20, 0x50, 0x65, 0x6c, 0x6c, 0x65, 0x6e,
		0x74, 0x65, 0x73, 0x71, 0x75, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x74, 0x69, 0x73, 0x20,
		0x73, 0x6f, 0x6c, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x75, 0x64, 0x69, 0x6e, 0x20, 0x6e,
		0x69, 0x62, 0x68, 0x20, 0x76, 0x65, 0x6c, 0x20, 0x74, 0x69, 0x6e, 0x63, 0x69, 0x64,
		0x75, 0x6e, 0x74, 0x2e, 0x20, 0x4e, 0x75, 0x6e, 0x63, 0x20, 0x61, 0x74, 0x20, 0x6e,
		0x75, 0x6e, 0x63, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x71, 0x75, 0x61, 0x74, 0x2c,
		0x20, 0x72, 0x75, 0x74, 0x72, 0x75, 0x6d, 0x20, 0x70, 0x75, 0x72, 0x75, 0x73, 0x20,
		0x69, 0x6e, 0x2c, 0x20, 0x76, 0x65, 0x6e, 0x65, 0x6e, 0x61, 0x74, 0x69, 0x73, 0x20,
		0x72, 0x69, 0x73, 0x75, 0x73, 0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x6c,
		0x69, 0x62, 0x65, 0x72, 0x6f, 0x20, 0x6c, 0x6f, 0x72, 0x65, 0x6d, 0x2c, 0x20, 0x74,
		0x69, 0x6e, 0x63, 0x69, 0x64, 0x75, 0x6e, 0x74, 0x20, 0x76, 0x65, 0x6c, 0x20, 0x6c,
		0x65, 0x6f, 0x20, 0x65, 0x67, 0x65, 0x74, 0x2c, 0x20, 0x66, 0x65, 0x72, 0x6d, 0x65,
		0x6e, 0x74, 0x75, 0x6d, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6d, 0x73, 0x61, 0x6e, 0x20,
		0x72, 0x69, 0x73, 0x75, 0x73, 0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x6d,
		0x61, 0x75, 0x72, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x75, 0x72, 0x69, 0x73, 0x2c, 0x20,
		0x65, 0x6c, 0x65, 0x69, 0x66, 0x65, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x6c, 0x65,
		0x6f, 0x20, 0x73, 0x65, 0x64, 0x2c, 0x20, 0x76, 0x65, 0x73, 0x74, 0x69, 0x62, 0x75,
		0x6c, 0x75, 0x6d, 0x20, 0x64, 0x69, 0x63, 0x74, 0x75, 0x6d, 0x20, 0x61, 0x6e, 0x74,
		0x65, 0x2e, 0x20, 0x56, 0x69, 0x76, 0x61, 0x6d, 0x75, 0x73, 0x20, 0x62, 0x69, 0x62,
		0x65, 0x6e, 0x64, 0x75, 0x6d, 0x20, 0x76, 0x65, 0x6e, 0x65, 0x6e, 0x61, 0x74, 0x69,
		0x73, 0x20, 0x6e, 0x69, 0x73, 0x69, 0x20, 0x75, 0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d,
		0x65, 0x6e, 0x74, 0x75, 0x6d, 0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x75,
		0x6c, 0x74, 0x72, 0x69, 0x63, 0x69, 0x65, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
		0x64, 0x6f, 0x20, 0x6c, 0x61, 0x6f, 0x72, 0x65, 0x65, 0x74, 0x2e, 0x20, 0x4d, 0x61,
		0x65, 0x63, 0x65, 0x6e, 0x61, 0x73, 0x20, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x73,
		0x69, 0x73, 0x20, 0x6e, 0x75, 0x6e, 0x63, 0x20, 0x61, 0x74, 0x20, 0x70, 0x72, 0x65,
		0x74, 0x69, 0x75, 0x6d, 0x20, 0x74, 0x72, 0x69, 0x73, 0x74, 0x69, 0x71, 0x75, 0x65,
		0x2e, 0x20, 0x44, 0x6f, 0x6e, 0x65, 0x63, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x20, 0x6c,
		0x65, 0x63, 0x74, 0x75, 0x73, 0x2c, 0x20, 0x64, 0x69, 0x63, 0x74, 0x75, 0x6d, 0x20,
		0x69, 0x64, 0x20, 0x66, 0x65, 0x6c, 0x69, 0x73, 0x20, 0x61, 0x63, 0x2c, 0x20, 0x6c,
		0x61, 0x63, 0x69, 0x6e, 0x69, 0x61, 0x20, 0x74, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x75,
		0x6e, 0x74, 0x20, 0x65, 0x72, 0x61, 0x74, 0x20, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x70,
		0x61, 0x74, 0x2e, 0x20 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 'Lorem ipsum dolor sit amet, consectetur '
		+ 'adipiscing elit. Pellentesque mattis sollicitudin nibh vel tincidunt. '
		+ 'Nunc at nunc consequat, rutrum purus in, venenatis risus. Donec libero '
		+ 'lorem, tincidunt vel leo eget, fermentum accumsan risus. Donec mauris '
		+ 'mauris, eleifend in leo sed, vestibulum dictum ante. Vivamus bibendum '
		+ 'venenatis nisi ut elementum. Donec ultricies commodo laoreet. Maecenas '
		+ 'facilisis nunc at pretium tristique. Donec elit lectus, dictum id felis '
		+ 'ac, lacinia tincidunt erat volutpat. ');
		assert.strictEqual(buffer.read, 505);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, '');
		assert.strictEqual(buffer.read, 4);
		}

		},
		'ByteArray parser' : {
		topic : function(parser) {
		return parser.parseByteArray.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd,
		0xef ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.toString('hex'), '0123456789abcdef');
		assert.strictEqual(buffer.read, 12);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.toString('hex'), '');
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Void parser' : {
		topic : function(parser) {
		return parser.parseVoid.bind(parser);
		},
		'should parse <empty Buffer>' : function(parse) {
		var buffer = new Buffer([]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isUndefined(value);
		assert.strictEqual(buffer.read, 0);
		}
		},
		'Array parser' : {
		topic : function(parser) {
		return parser.parseArray.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, []);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, [ undefined, 49 ]);
		assert.strictEqual(buffer.read, 7);
		}
		},
		'Table parser' : {
		topic : function(parser) {
		return parser.parseTable.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, {});
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62, 0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, {
		test : 49
		});
		assert.strictEqual(buffer.read, 11);
		}
		},
		'Value parser' : {
		topic : function(parser) {
		return parser.parseValue.bind(parser);
		},
		'should parse 0x74, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x74, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, true);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x62, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x62, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x73, 0xff, 0xf1' : function(parse) {
		var buffer = new Buffer([ 0x73, 0xff, 0xf1 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -15);
		assert.strictEqual(buffer.read, 3);
		},
		'should parse 0x49, 0xff, 0xf1, 0x2a, 0x91' : function(parse) {
		var buffer = new Buffer([ 0x49, 0xff, 0xf1, 0x2a, 0x91 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -972143);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x6c, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12' : function(parse) {
		var buffer = new Buffer([ 0x6c, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 180140122183954);
		assert.strictEqual(buffer.read, 9);
		},
		'should parse 0x66, 0x1a, 0xf1, 0x2a, 0x91' : function(parse) {
		var buffer = new Buffer([ 0x66, 0x1a, 0xf1, 0x2a, 0x91 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 9.974403355091338e-23);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x64, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12' : function(parse) {
		var buffer = new Buffer([ 0x64, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 8.90010458087363e-310);
		assert.strictEqual(buffer.read, 9);
		},
		'should parse 0x44, 0x02, 0x00, 0x00, 0x01, 0x5e' : function(parse) {
		var buffer = new Buffer([ 0x44, 0x02, 0x00, 0x00, 0x01, 0x5e ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3.50);
		assert.strictEqual(buffer.read, 6);
		},
		'should parse 0x53, 0x00, 0x00, 0x00, 0x08, 0x77, 0x75, 0x74, 0x74, 0x77, 0x75, 0x74, 0x74' : function(parse) {
		var buffer = new Buffer([ 0x53, 0x00, 0x00, 0x00, 0x08, 0x77, 0x75, 0x74, 0x74, 0x77, 0x75,
		0x74, 0x74 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 'wuttwutt');
		assert.strictEqual(buffer.read, 13);
		},
		'should parse 0x41, 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x41, 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, [ undefined, 49 ]);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x54, 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69' : function(parse) {
		var buffer = new Buffer([ 0x54, 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Thu, 14 Nov 2013 19:32:57 GMT').getTime());
		assert.strictEqual(buffer.read, 9);
		},
		'should parse 0x46, 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x46, 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62,
		0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, {
		test : 49
		});
		assert.strictEqual(buffer.read, 12);
		},
		'should parse 0x56' : function(parse) {
		var buffer = new Buffer([ 0x56 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, undefined);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0x78, 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef' : function(parse) {
		var buffer = new Buffer([ 0x78, 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
		0xcd, 0xef ]);
		buffer.read = 0;
		var value = parse(buffer);
		var testValue = new Buffer([ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef ]);
		assert.strictEqual(value.length, testValue.length);
		for (var i = 0; i < 8; i++) {
		assert.strictEqual(value[i], testValue[i]);
		}
		assert.strictEqual(buffer.read, 13);
		}
		},
		'ByteArray parser' : {
		topic : function(parser) {
		return parser.parseByteArray.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd,
		0xef ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.toString('hex'), '0123456789abcdef');
		assert.strictEqual(buffer.read, 12);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.toString('hex'), '');
		assert.strictEqual(buffer.read, 4);
		}
		},
		'Void parser' : {
		topic : function(parser) {
		return parser.parseVoid.bind(parser);
		},
		'should parse <empty Buffer>' : function(parse) {
		var buffer = new Buffer([]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.isUndefined(value);
		assert.strictEqual(buffer.read, 0);
		}
		},
		'Array parser' : {
		topic : function(parser) {
		return parser.parseArray.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, []);
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, [ undefined, 49 ]);
		assert.strictEqual(buffer.read, 7);
		}
		},
		'Table parser' : {
		topic : function(parser) {
		return parser.parseTable.bind(parser);
		},
		'should parse 0x00, 0x00, 0x00, 0x00' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x00 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, {});
		assert.strictEqual(buffer.read, 4);
		},
		'should parse 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62, 0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, {
		test : 49
		});
		assert.strictEqual(buffer.read, 11);
		}
		},
		'Value parser' : {
		topic : function(parser) {
		return parser.parseValue.bind(parser);
		},
		'should parse 0x74, 0x01' : function(parse) {
		var buffer = new Buffer([ 0x74, 0x01 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, true);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x62, 0x03' : function(parse) {
		var buffer = new Buffer([ 0x62, 0x03 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3);
		assert.strictEqual(buffer.read, 2);
		},
		'should parse 0x73, 0xff, 0xf1' : function(parse) {
		var buffer = new Buffer([ 0x73, 0xff, 0xf1 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -15);
		assert.strictEqual(buffer.read, 3);
		},
		'should parse 0x49, 0xff, 0xf1, 0x2a, 0x91' : function(parse) {
		var buffer = new Buffer([ 0x49, 0xff, 0xf1, 0x2a, 0x91 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, -972143);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x6c, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12' : function(parse) {
		var buffer = new Buffer([ 0x6c, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 180140122183954);
		assert.strictEqual(buffer.read, 9);
		},
		'should parse 0x66, 0x1a, 0xf1, 0x2a, 0x91' : function(parse) {
		var buffer = new Buffer([ 0x66, 0x1a, 0xf1, 0x2a, 0x91 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 9.974403355091338e-23);
		assert.strictEqual(buffer.read, 5);
		},
		'should parse 0x64, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12' : function(parse) {
		var buffer = new Buffer([ 0x64, 0x00, 0x00, 0xa3, 0xd6, 0x23, 0xfe, 0x19, 0x12 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 8.90010458087363e-310);
		assert.strictEqual(buffer.read, 9);
		},
		'should parse 0x44, 0x02, 0x00, 0x00, 0x01, 0x5e' : function(parse) {
		var buffer = new Buffer([ 0x44, 0x02, 0x00, 0x00, 0x01, 0x5e ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 3.50);
		assert.strictEqual(buffer.read, 6);
		},
		'should parse 0x53, 0x00, 0x00, 0x00, 0x08, 0x77, 0x75, 0x74, 0x74, 0x77, 0x75, 0x74, 0x74' : function(parse) {
		var buffer = new Buffer([ 0x53, 0x00, 0x00, 0x00, 0x08, 0x77, 0x75, 0x74, 0x74, 0x77, 0x75,
		0x74, 0x74 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, 'wuttwutt');
		assert.strictEqual(buffer.read, 13);
		},
		'should parse 0x41, 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x41, 0x00, 0x00, 0x00, 0x03, 0x56, 0x62, 0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, [ undefined, 49 ]);
		assert.strictEqual(buffer.read, 8);
		},
		'should parse 0x54, 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69' : function(parse) {
		var buffer = new Buffer([ 0x54, 0x00, 0x00, 0x00, 0x00, 0x52, 0x85, 0x25, 0x69 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value.getTime(), new Date('Thu, 14 Nov 2013 19:32:57 GMT').getTime());
		assert.strictEqual(buffer.read, 9);
		},
		'should parse 0x46, 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62, 0x31' : function(parse) {
		var buffer = new Buffer([ 0x46, 0x00, 0x00, 0x00, 0x07, 0x04, 0x74, 0x65, 0x73, 0x74, 0x62,
		0x31 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.deepEqual(value, {
		test : 49
		});
		assert.strictEqual(buffer.read, 12);
		},
		'should parse 0x56' : function(parse) {
		var buffer = new Buffer([ 0x56 ]);
		buffer.read = 0;
		var value = parse(buffer);
		assert.strictEqual(value, undefined);
		assert.strictEqual(buffer.read, 1);
		},
		'should parse 0x78, 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef' : function(parse) {
		var buffer = new Buffer([ 0x78, 0x00, 0x00, 0x00, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
		0xcd, 0xef ]);
		buffer.read = 0;
		var value = parse(buffer);
		var testValue = new Buffer([ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef ]);
		assert.strictEqual(value.length, testValue.length);
		for (var i = 0; i < 8; i++) {
		assert.strictEqual(value[i], testValue[i]);
		}
		assert.strictEqual(buffer.read, 13);
		}
		}).export(module);
		}
		}
		}).export(module);

2219

test/frameSerializer-test.js

		@@ -11,1114 +11,1111 @@ var vows = require('vows');

		vows
		.describe('frameSerializer')
		.addBatch(
		{
		'The AMQP 0-9-1-extended' : {
		topic : function() {
		var self = this;
		specification.selectSpecification('rabbitmq/full/amqp0-9-1.stripped.extended', function() {
		specification.getSpecification(function(spec) {
		var a = new FrameSerializer(spec);
		self.callback(null, a);
		});
		});
		},
		'Octet serializer' : {
		topic : function(serializer) {
		return serializer.serializeOctet.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '03');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize 255' : function(serialize) {
		var value = 255;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ff');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Signed Octet serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedOctet.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '03');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fd');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ff');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Short serializer' : {
		topic : function(serializer) {
		return serializer.serializeShort.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize 867' : function(serialize) {
		var value = 867;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize 65535' : function(serialize) {
		var value = 65535;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffff');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000');
		assert.strictEqual(buffer.used, 2);
		}
		},
		'Signed Short serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedShort.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fffd');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize 867' : function(serialize) {
		var value = 867;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffff');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000');
		assert.strictEqual(buffer.used, 2);
		}
		},
		'Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000003');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 56877370' : function(serialize) {
		var value = 56877370;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13a');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 4294967295' : function(serialize) {
		var value = 4294967295;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffff');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Signed Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000003');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fffffffd');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 56877370' : function(serialize) {
		var value = 56877370;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13a');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffff');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Long Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeLongLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000003');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1092066989945895' : function(serialize) {
		var value = 1092066989945895;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'0363e13aa901b429\'' : function(serialize) {
		var value = '0363e13aa901b427';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 18446744073709551615' : function(serialize) {
		var value = 18446744073709551615;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'ffffffffffffffff\'' : function(serialize) {
		var value = 'ffffffffffffffff';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Signed Long Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedLongLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000003');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fffffffffffffffd');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1092066989945895' : function(serialize) {
		var value = 1092066989945895;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'0363e13aa901b429\'' : function(serialize) {
		var value = '0363e13aa901b427';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'ffffffffffffffff\'' : function(serialize) {
		var value = 'ffffffffffffffff';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Boolean serializer' : {
		topic : function(serializer) {
		return serializer.serializeBoolean.bind(serializer);
		},
		'should serialize true' : function(serialize) {
		var value = true;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '01');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize false' : function(serialize) {
		var value = false;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize 1' : function(serialize) {
		var value = 1;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '01');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize 0' : function(serialize) {
		var value = 0;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Float serializer' : {
		topic : function(serializer) {
		return serializer.serializeFloat.bind(serializer);
		},
		'should serialize 1' : function(serialize) {
		var value = 1;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3f800000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -2' : function(serialize) {
		var value = -2;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'c0000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 3.4028234663852886e+38' : function(serialize) {
		var value = 3.4028234663852886e+38;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7f7fffff');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 0' : function(serialize) {
		var value = 0;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -0' : function(serialize) {
		var value = -0;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '80000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize Infinity' : function(serialize) {
		var value = Infinity;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7f800000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -Infinity' : function(serialize) {
		var value = -Infinity;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ff800000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize NaN' : function(serialize) {
		var value = NaN;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7fc00000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 1/3' : function(serialize) {
		var value = 1 / 3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3eaaaaab');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Double serializer' : {
		topic : function(serializer) {
		return serializer.serializeDouble.bind(serializer);
		},
		'should serialize 1' : function(serialize) {
		var value = 1;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3ff0000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1.0000000000000002' : function(serialize) {
		var value = 1.0000000000000002;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3ff0000000000001');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1.0000000000000004' : function(serialize) {
		var value = 1.0000000000000004;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3ff0000000000002');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 2' : function(serialize) {
		var value = 2;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '4000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -2' : function(serialize) {
		var value = -2;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'c000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 0' : function(serialize) {
		var value = 0;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -0' : function(serialize) {
		var value = -0;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '8000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize Infinity' : function(serialize) {
		var value = Infinity;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7ff0000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -Infinity' : function(serialize) {
		var value = -Infinity;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fff0000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize NaN' : function(serialize) {
		var value = NaN;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7ff8000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1/3' : function(serialize) {
		var value = 1 / 3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3fd5555555555555');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Bit Pack serializer' : {
		topic : function(serializer) {
		return serializer.serializeBitPack.bind(serializer);
		},
		'should serialize f f f f f f f f' : function(serialize) {
		var value = [ false, false, false, false, false, false, false, false ];
		var buffer = new Buffer(1);
		buffer.used = 0;
		for (var i = 0; i < 8; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize t t t t t t t t' : function(serialize) {
		var value = [ true, true, true, true, true, true, true, true ];
		var buffer = new Buffer(1);
		buffer.used = 0;
		for (var i = 0; i < 8; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'ff');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize t t f t f t f t' : function(serialize) {
		var value = [ true, true, false, true, false, true, false, true ];
		var buffer = new Buffer(1);
		buffer.used = 0;
		for (var i = 0; i < 8; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'ab');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize t t f t f t f t t t' : function(serialize) {
		var value = [ true, true, false, true, false, true, false, true, true, true ];
		var buffer = new Buffer(2);
		buffer.used = 0;
		for (var i = 0; i < 10; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'ab03');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize t t f t f t f t t t f t f t f t' : function(serialize) {
		var value = [ true, true, false, true, false, true, false, true, true, true, false,
		true, false, true, false, true ];
		var buffer = new Buffer(2);
		buffer.used = 0;
		for (var i = 0; i < 16; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'abab');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value, 0);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Decimal serializer' : {
		topic : function(serializer) {
		return serializer.serializeDecimal.bind(serializer);
		},
		'should serialize 0' : function(serialize) {
		var value = {
		digits : 0,
		value : 0
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize 3' : function(serialize) {
		var value = {
		digits : 0,
		value : 3
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000003');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize 0.03' : function(serialize) {
		var value = {
		digits : 2,
		value : 0.03
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0200000003');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize -0.03' : function(serialize) {
		var value = {
		digits : 2,
		value : -0.03
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '02fffffffd');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000');
		assert.strictEqual(buffer.used, 5);
		}
		},
		'Timestamp serializer' : {
		topic : function(serializer) {
		return serializer.serializeTimestamp.bind(serializer);
		},
		'should serialize Thu, 01 Jan 1970 00:00:00 GMT' : function(serialize) {
		var value = new Date('Thu, 01 Jan 1970 00:00:00 GMT');
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize Wed, 31 Dec 1969 23:59:59 GMT' : function(serialize) {
		var value = new Date('Wed, 31 Dec 1969 23:59:59 GMT');
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.notStrictEqual(buffer.toString('hex'), '0000000000000000');
		// TODO test correct value
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Short String serializer' : {
		topic : function(serializer) {
		return serializer.serializeShortString.bind(serializer);
		},
		'should serialize \'Hello World!\'' : function(serialize) {
		var value = 'Hello World!';
		var buffer = new Buffer(13);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0c48656c6c6f20576f726c6421');
		assert.strictEqual(buffer.used, 13);
		},
		'should serialize \'\'' : function(serialize) {
		var value = '';
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Long String serializer' : {
		topic : function(serializer) {
		return serializer.serializeLongString.bind(serializer);
		},
		'should serialize \'Lorem ipsum dolor sit amet...\'' : function(serialize) {
		var value = 'Lorem ipsum dolor sit amet, consectetur '
		+ 'adipiscing elit. Pellentesque mattis sollicitudin nibh vel tincidunt. '
		+ 'Nunc at nunc consequat, rutrum purus in, venenatis risus. Donec libero '
		+ 'lorem, tincidunt vel leo eget, fermentum accumsan risus. Donec mauris '
		+ 'mauris, eleifend in leo sed, vestibulum dictum ante. Vivamus bibendum '
		+ 'venenatis nisi ut elementum. Donec ultricies commodo laoreet. Maecenas '
		+ 'facilisis nunc at pretium tristique. Donec elit lectus, dictum id felis '
		+ 'ac, lacinia tincidunt erat volutpat. ';
		var buffer = new Buffer(505);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '000001f54c6f72656d20697073756d20646'
		+ 'f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e'
		+ '6720656c69742e2050656c6c656e746573717565206d617474697320736f6c6c6963697'
		+ '47564696e206e6962682076656c2074696e636964756e742e204e756e63206174206e75'
		+ '6e6320636f6e7365717561742c2072757472756d20707572757320696e2c2076656e656'
		+ 'e617469732072697375732e20446f6e6563206c696265726f206c6f72656d2c2074696e'
		+ '636964756e742076656c206c656f20656765742c206665726d656e74756d20616363756'
		+ 'd73616e2072697375732e20446f6e6563206d6175726973206d61757269732c20656c65'
		+ '6966656e6420696e206c656f207365642c20766573746962756c756d2064696374756d2'
		+ '0616e74652e20566976616d757320626962656e64756d2076656e656e61746973206e69'
		+ '736920757420656c656d656e74756d2e20446f6e656320756c7472696369657320636f6'
		+ 'd6d6f646f206c616f726565742e204d616563656e617320666163696c69736973206e75'
		+ '6e63206174207072657469756d207472697374697175652e20446f6e656320656c69742'
		+ '06c65637475732c2064696374756d2069642066656c69732061632c206c6163696e6961'
		+ '2074696e636964756e74206572617420766f6c75747061742e20');
		assert.strictEqual(buffer.used, 505);
		},
		'should serialize \'\'' : function(serialize) {
		var value = '';
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Byte Array serializer' : {
		topic : function(serializer) {
		return serializer.serializeByteArray.bind(serializer);
		},
		'should serialize 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef' : function(serialize) {
		var value = new Buffer([ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef ]);
		var buffer = new Buffer(12);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '000000080123456789abcdef');
		assert.strictEqual(buffer.used, 12);
		},
		'should serialize <empty Buffer>' : function(serialize) {
		var value = new Buffer([]);
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Void serializer' : {
		topic : function(serializer) {
		return serializer.serializeVoid.bind(serializer);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(0);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '');
		assert.strictEqual(buffer.used, 0);
		}
		},
		'Array serializer' : {
		topic : function(serializer) {
		return serializer.serializeArray.bind(serializer);
		},
		'should serialize []' : function(serialize) {
		var value = [];
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize [{type:\'Void\',data:undefined},{type:\'Signed 8-bit\',data:49}]' : function(serialize) {
		var value = [ {
		type : 'Void',
		data : undefined
		}, {
		type : 'Signed 8-bit',
		data : 49
		} ];
		var buffer = new Buffer(7);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000003566231');
		assert.strictEqual(buffer.used, 7);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Table serializer' : {
		topic : function(serializer) {
		return serializer.serializeTable.bind(serializer);
		},
		'should serialize {}' : function(serialize) {
		var value = {};
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize {test:{type:\'Signed 8-bit\',data:49}}' : function(serialize) {
		var value = {
		test : {
		type : 'Signed 8-bit',
		data : 49
		}
		};
		var buffer = new Buffer(11);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000704746573746231');
		assert.strictEqual(buffer.used, 11);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Value serializer' : {
		topic : function(serializer) {
		return serializer.serializeValue.bind(serializer);
		},
		'should serialize {type:\'Boolean\',data:true}' : function(serialize) {
		var value = {
		type : 'Boolean',
		data : true
		};
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7401');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize {type:\'Signed 8-bit\',data:3}' : function(serialize) {
		var value = {
		type : 'Signed 8-bit',
		data : 3
		};
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '6203');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize {type:\'Signed 16-bit\',data:-15}' : function(serialize) {
		var value = {
		type : 'Signed 16-bit',
		data : -15
		};
		var buffer = new Buffer(3);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '73fff1');
		assert.strictEqual(buffer.used, 3);
		},
		'should serialize {type:\'Signed 32-bit\',data:-972143}' : function(serialize) {
		var value = {
		type : 'Signed 32-bit',
		data : -972143
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '49fff12a91');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize {type:\'Signed 64-bit\',data:180140122183954}' : function(serialize) {
		var value = {
		type : 'Signed 64-bit',
		data : 180140122183954
		};
		var buffer = new Buffer(9);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '6c0000a3d623fe1912');
		assert.strictEqual(buffer.used, 9);
		},
		'should serialize {type:\'32-bit float\',data:9.974403355091338e-23}' : function(serialize) {
		var value = {
		type : '32-bit float',
		data : 9.974403355091338e-23
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '661af12a91');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize {type:\'64-bit float\',data:8.90010458087363e-310}' : function(serialize) {
		var value = {
		type : '64-bit float',
		data : 8.90010458087363e-310
		};
		var buffer = new Buffer(9);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '640000a3d623fe1912');
		assert.strictEqual(buffer.used, 9);
		},
		'should serialize {type:\'Decimal\',data:{digits:2,value:3.5}}' : function(serialize) {
		var value = {
		type : 'Decimal',
		data : {
		digits : 2,
		value : 3.5
		}
		};
		var buffer = new Buffer(6);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '44020000015e');
		assert.strictEqual(buffer.used, 6);
		},
		'should serialize {type:\'Long string\',data:\'wuttwutt\'}' : function(serialize) {
		var value = {
		type : 'Long string',
		data : 'wuttwutt'
		};
		var buffer = new Buffer(13);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '53000000087775747477757474');
		assert.strictEqual(buffer.used, 13);
		},
		'should serialize {type:\'Array\',data:[{type:\'Void\',data:undefined},{type:\'Signed 8-bit\',data:49}]}' : function(serialize) {
		var value = {
		type : 'Array',
		data : [ {
		type : 'Void',
		data : undefined
		}, {
		type : 'Signed 8-bit',
		data : 49
		} ]
		};
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '4100000003566231');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize {type:\'Timestamp\',data:new Date(\'Thu, 14 Nov 2013 19:32:57 GMT\')}' : function(serialize) {
		var value = {
		type : 'Timestamp',
		data : new Date('Thu, 14 Nov 2013 19:32:57 GMT')
		};
		var buffer = new Buffer(9);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '540000000052852569');
		assert.strictEqual(buffer.used, 9);
		},
		'should serialize {type:\'Nested Table\',data:{test:{type:\'Signed 8-bit\',data:49}}}' : function(serialize) {
		var value = {
		type : 'Nested Table',
		data : {
		test : {
		type : 'Signed 8-bit',
		data : 49
		}
		}
		};
		var buffer = new Buffer(12);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '460000000704746573746231');
		assert.strictEqual(buffer.used, 12);
		},
		'should serialize {type:\'Void\',data:undefined}' : function(serialize) {
		var value = {
		type : 'Void',
		data : undefined
		};
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '56');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize {type:\'Byte array\',data:new Buffer([0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef])}' : function(serialize) {
		var value = {
		type : 'Byte array',
		data : new Buffer([ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef ])
		};
		var buffer = new Buffer(13);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '78000000080123456789abcdef');
		assert.strictEqual(buffer.used, 13);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '56');
		assert.strictEqual(buffer.used, 1);
		}
		vows.describe('frameSerializer').addBatch({
		'The AMQP 0-9-1-extended' : {
		topic : function() {
		var self = this;
		specification.selectSpecification('rabbitmq/full/amqp0-9-1.stripped.extended', function() {
		specification.getSpecification(function(spec) {
		var a = new FrameSerializer(spec);
		self.callback(null, a);
		});
		});
		},
		'Octet serializer' : {
		topic : function(serializer) {
		return serializer.serializeOctet.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '03');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize 255' : function(serialize) {
		var value = 255;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ff');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Signed Octet serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedOctet.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '03');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fd');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ff');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Short serializer' : {
		topic : function(serializer) {
		return serializer.serializeShort.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize 867' : function(serialize) {
		var value = 867;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize 65535' : function(serialize) {
		var value = 65535;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffff');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000');
		assert.strictEqual(buffer.used, 2);
		}
		},
		'Signed Short serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedShort.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fffd');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize 867' : function(serialize) {
		var value = 867;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffff');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000');
		assert.strictEqual(buffer.used, 2);
		}
		},
		'Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000003');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 56877370' : function(serialize) {
		var value = 56877370;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13a');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 4294967295' : function(serialize) {
		var value = 4294967295;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffff');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Signed Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000003');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fffffffd');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 56877370' : function(serialize) {
		var value = 56877370;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13a');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffff');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Long Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeLongLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000003');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1092066989945895' : function(serialize) {
		var value = 1092066989945895;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'0363e13aa901b429\'' : function(serialize) {
		var value = '0363e13aa901b427';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 18446744073709551615' : function(serialize) {
		var value = 18446744073709551615;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'ffffffffffffffff\'' : function(serialize) {
		var value = 'ffffffffffffffff';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Signed Long Long serializer' : {
		topic : function(serializer) {
		return serializer.serializeSignedLongLong.bind(serializer);
		},
		'should serialize 3' : function(serialize) {
		var value = 3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000003');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -3' : function(serialize) {
		var value = -3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fffffffffffffffd');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1092066989945895' : function(serialize) {
		var value = 1092066989945895;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0003e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'0363e13aa901b429\'' : function(serialize) {
		var value = '0363e13aa901b427';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0363e13aa901b427');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -1' : function(serialize) {
		var value = -1;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize \'ffffffffffffffff\'' : function(serialize) {
		var value = 'ffffffffffffffff';
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Boolean serializer' : {
		topic : function(serializer) {
		return serializer.serializeBoolean.bind(serializer);
		},
		'should serialize true' : function(serialize) {
		var value = true;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '01');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize false' : function(serialize) {
		var value = false;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize 1' : function(serialize) {
		var value = 1;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '01');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize 0' : function(serialize) {
		var value = 0;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Float serializer' : {
		topic : function(serializer) {
		return serializer.serializeFloat.bind(serializer);
		},
		'should serialize 1' : function(serialize) {
		var value = 1;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3f800000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -2' : function(serialize) {
		var value = -2;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'c0000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 3.4028234663852886e+38' : function(serialize) {
		var value = 3.4028234663852886e+38;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7f7fffff');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 0' : function(serialize) {
		var value = 0;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -0' : function(serialize) {
		var value = -0;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '80000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize Infinity' : function(serialize) {
		var value = Infinity;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7f800000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize -Infinity' : function(serialize) {
		var value = -Infinity;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ff800000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize NaN' : function(serialize) {
		var value = NaN;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7fc00000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize 1/3' : function(serialize) {
		var value = 1 / 3;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3eaaaaab');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Double serializer' : {
		topic : function(serializer) {
		return serializer.serializeDouble.bind(serializer);
		},
		'should serialize 1' : function(serialize) {
		var value = 1;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3ff0000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1.0000000000000002' : function(serialize) {
		var value = 1.0000000000000002;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3ff0000000000001');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1.0000000000000004' : function(serialize) {
		var value = 1.0000000000000004;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3ff0000000000002');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 2' : function(serialize) {
		var value = 2;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '4000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -2' : function(serialize) {
		var value = -2;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'c000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 0' : function(serialize) {
		var value = 0;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -0' : function(serialize) {
		var value = -0;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '8000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize Infinity' : function(serialize) {
		var value = Infinity;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7ff0000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize -Infinity' : function(serialize) {
		var value = -Infinity;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'fff0000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize NaN' : function(serialize) {
		var value = NaN;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7ff8000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize 1/3' : function(serialize) {
		var value = 1 / 3;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '3fd5555555555555');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Bit Pack serializer' : {
		topic : function(serializer) {
		return serializer.serializeBitPack.bind(serializer);
		},
		'should serialize f f f f f f f f' : function(serialize) {
		var value = [ false, false, false, false, false, false, false, false ];
		var buffer = new Buffer(1);
		buffer.used = 0;
		for (var i = 0; i < 8; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize t t t t t t t t' : function(serialize) {
		var value = [ true, true, true, true, true, true, true, true ];
		var buffer = new Buffer(1);
		buffer.used = 0;
		for (var i = 0; i < 8; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'ff');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize t t f t f t f t' : function(serialize) {
		var value = [ true, true, false, true, false, true, false, true ];
		var buffer = new Buffer(1);
		buffer.used = 0;
		for (var i = 0; i < 8; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'ab');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize t t f t f t f t t t' : function(serialize) {
		var value = [ true, true, false, true, false, true, false, true, true, true ];
		var buffer = new Buffer(2);
		buffer.used = 0;
		for (var i = 0; i < 10; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'ab03');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize t t f t f t f t t t f t f t f t' : function(serialize) {
		var value = [ true, true, false, true, false, true, false, true, true, true, false,
		true, false, true, false, true ];
		var buffer = new Buffer(2);
		buffer.used = 0;
		for (var i = 0; i < 16; i++) {
		serialize(buffer, value[i], i);
		}
		assert.strictEqual(buffer.toString('hex'), 'abab');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value, 0);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Decimal serializer' : {
		topic : function(serializer) {
		return serializer.serializeDecimal.bind(serializer);
		},
		'should serialize 0' : function(serialize) {
		var value = {
		digits : 0,
		value : 0
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize 3' : function(serialize) {
		var value = {
		digits : 0,
		value : 3
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000003');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize 0.03' : function(serialize) {
		var value = {
		digits : 2,
		value : 0.03
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0200000003');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize -0.03' : function(serialize) {
		var value = {
		digits : 2,
		value : -0.03
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '02fffffffd');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000');
		assert.strictEqual(buffer.used, 5);
		}
		},
		'Timestamp serializer' : {
		topic : function(serializer) {
		return serializer.serializeTimestamp.bind(serializer);
		},
		'should serialize Thu, 01 Jan 1970 00:00:00 GMT' : function(serialize) {
		var value = new Date('Thu, 01 Jan 1970 00:00:00 GMT');
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000000000000');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize Wed, 31 Dec 1969 23:59:59 GMT' : function(serialize) {
		var value = new Date('Wed, 31 Dec 1969 23:59:59 GMT');
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), 'ffffffffffffffff');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.notStrictEqual(buffer.toString('hex'), '0000000000000000');
		// TODO test correct value
		assert.strictEqual(buffer.used, 8);
		}
		},
		'Short String serializer' : {
		topic : function(serializer) {
		return serializer.serializeShortString.bind(serializer);
		},
		'should serialize \'Hello World!\'' : function(serialize) {
		var value = 'Hello World!';
		var buffer = new Buffer(13);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0c48656c6c6f20576f726c6421');
		assert.strictEqual(buffer.used, 13);
		},
		'should serialize \'\'' : function(serialize) {
		var value = '';
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00');
		assert.strictEqual(buffer.used, 1);
		}
		},
		'Long String serializer' : {
		topic : function(serializer) {
		return serializer.serializeLongString.bind(serializer);
		},
		'should serialize \'Lorem ipsum dolor sit amet...\'' : function(serialize) {
		var value = 'Lorem ipsum dolor sit amet, consectetur '
		+ 'adipiscing elit. Pellentesque mattis sollicitudin nibh vel tincidunt. '
		+ 'Nunc at nunc consequat, rutrum purus in, venenatis risus. Donec libero '
		+ 'lorem, tincidunt vel leo eget, fermentum accumsan risus. Donec mauris '
		+ 'mauris, eleifend in leo sed, vestibulum dictum ante. Vivamus bibendum '
		+ 'venenatis nisi ut elementum. Donec ultricies commodo laoreet. Maecenas '
		+ 'facilisis nunc at pretium tristique. Donec elit lectus, dictum id felis '
		+ 'ac, lacinia tincidunt erat volutpat. ';
		var buffer = new Buffer(505);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '000001f54c6f72656d20697073756d20646'
		+ 'f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e'
		+ '6720656c69742e2050656c6c656e746573717565206d617474697320736f6c6c6963697'
		+ '47564696e206e6962682076656c2074696e636964756e742e204e756e63206174206e75'
		+ '6e6320636f6e7365717561742c2072757472756d20707572757320696e2c2076656e656'
		+ 'e617469732072697375732e20446f6e6563206c696265726f206c6f72656d2c2074696e'
		+ '636964756e742076656c206c656f20656765742c206665726d656e74756d20616363756'
		+ 'd73616e2072697375732e20446f6e6563206d6175726973206d61757269732c20656c65'
		+ '6966656e6420696e206c656f207365642c20766573746962756c756d2064696374756d2'
		+ '0616e74652e20566976616d757320626962656e64756d2076656e656e61746973206e69'
		+ '736920757420656c656d656e74756d2e20446f6e656320756c7472696369657320636f6'
		+ 'd6d6f646f206c616f726565742e204d616563656e617320666163696c69736973206e75'
		+ '6e63206174207072657469756d207472697374697175652e20446f6e656320656c69742'
		+ '06c65637475732c2064696374756d2069642066656c69732061632c206c6163696e6961'
		+ '2074696e636964756e74206572617420766f6c75747061742e20');
		assert.strictEqual(buffer.used, 505);
		},
		'should serialize \'\'' : function(serialize) {
		var value = '';
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Byte Array serializer' : {
		topic : function(serializer) {
		return serializer.serializeByteArray.bind(serializer);
		},
		'should serialize 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef' : function(serialize) {
		var value = new Buffer([ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef ]);
		var buffer = new Buffer(12);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '000000080123456789abcdef');
		assert.strictEqual(buffer.used, 12);
		},
		'should serialize <empty Buffer>' : function(serialize) {
		var value = new Buffer([]);
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Void serializer' : {
		topic : function(serializer) {
		return serializer.serializeVoid.bind(serializer);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(0);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '');
		assert.strictEqual(buffer.used, 0);
		}
		},
		'Array serializer' : {
		topic : function(serializer) {
		return serializer.serializeArray.bind(serializer);
		},
		'should serialize []' : function(serialize) {
		var value = [];
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize [{type:\'Void\',data:undefined},{type:\'Signed 8-bit\',data:49}]' : function(serialize) {
		var value = [ {
		type : 'Void',
		data : undefined
		}, {
		type : 'Signed 8-bit',
		data : 49
		} ];
		var buffer = new Buffer(7);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000003566231');
		assert.strictEqual(buffer.used, 7);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Table serializer' : {
		topic : function(serializer) {
		return serializer.serializeTable.bind(serializer);
		},
		'should serialize {}' : function(serialize) {
		var value = {};
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		},
		'should serialize {test:{type:\'Signed 8-bit\',data:49}}' : function(serialize) {
		var value = {
		test : {
		type : 'Signed 8-bit',
		data : 49
		}
		};
		var buffer = new Buffer(11);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '0000000704746573746231');
		assert.strictEqual(buffer.used, 11);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(4);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '00000000');
		assert.strictEqual(buffer.used, 4);
		}
		},
		'Value serializer' : {
		topic : function(serializer) {
		return serializer.serializeValue.bind(serializer);
		},
		'should serialize {type:\'Boolean\',data:true}' : function(serialize) {
		var value = {
		type : 'Boolean',
		data : true
		};
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '7401');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize {type:\'Signed 8-bit\',data:3}' : function(serialize) {
		var value = {
		type : 'Signed 8-bit',
		data : 3
		};
		var buffer = new Buffer(2);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '6203');
		assert.strictEqual(buffer.used, 2);
		},
		'should serialize {type:\'Signed 16-bit\',data:-15}' : function(serialize) {
		var value = {
		type : 'Signed 16-bit',
		data : -15
		};
		var buffer = new Buffer(3);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '73fff1');
		assert.strictEqual(buffer.used, 3);
		},
		'should serialize {type:\'Signed 32-bit\',data:-972143}' : function(serialize) {
		var value = {
		type : 'Signed 32-bit',
		data : -972143
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '49fff12a91');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize {type:\'Signed 64-bit\',data:180140122183954}' : function(serialize) {
		var value = {
		type : 'Signed 64-bit',
		data : 180140122183954
		};
		var buffer = new Buffer(9);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '6c0000a3d623fe1912');
		assert.strictEqual(buffer.used, 9);
		},
		'should serialize {type:\'32-bit float\',data:9.974403355091338e-23}' : function(serialize) {
		var value = {
		type : '32-bit float',
		data : 9.974403355091338e-23
		};
		var buffer = new Buffer(5);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '661af12a91');
		assert.strictEqual(buffer.used, 5);
		},
		'should serialize {type:\'64-bit float\',data:8.90010458087363e-310}' : function(serialize) {
		var value = {
		type : '64-bit float',
		data : 8.90010458087363e-310
		};
		var buffer = new Buffer(9);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '640000a3d623fe1912');
		assert.strictEqual(buffer.used, 9);
		},
		'should serialize {type:\'Decimal\',data:{digits:2,value:3.5}}' : function(serialize) {
		var value = {
		type : 'Decimal',
		data : {
		digits : 2,
		value : 3.5
		}
		};
		var buffer = new Buffer(6);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '44020000015e');
		assert.strictEqual(buffer.used, 6);
		},
		'should serialize {type:\'Long string\',data:\'wuttwutt\'}' : function(serialize) {
		var value = {
		type : 'Long string',
		data : 'wuttwutt'
		};
		var buffer = new Buffer(13);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '53000000087775747477757474');
		assert.strictEqual(buffer.used, 13);
		},
		'should serialize {type:\'Array\',data:[{type:\'Void\',data:undefined},{type:\'Signed 8-bit\',data:49}]}' : function(serialize) {
		var value = {
		type : 'Array',
		data : [ {
		type : 'Void',
		data : undefined
		}, {
		type : 'Signed 8-bit',
		data : 49
		} ]
		};
		var buffer = new Buffer(8);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '4100000003566231');
		assert.strictEqual(buffer.used, 8);
		},
		'should serialize {type:\'Timestamp\',data:new Date(\'Thu, 14 Nov 2013 19:32:57 GMT\')}' : function(serialize) {
		var value = {
		type : 'Timestamp',
		data : new Date('Thu, 14 Nov 2013 19:32:57 GMT')
		};
		var buffer = new Buffer(9);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '540000000052852569');
		assert.strictEqual(buffer.used, 9);
		},
		'should serialize {type:\'Nested Table\',data:{test:{type:\'Signed 8-bit\',data:49}}}' : function(serialize) {
		var value = {
		type : 'Nested Table',
		data : {
		test : {
		type : 'Signed 8-bit',
		data : 49
		}
		}
		}).export(module);
		};
		var buffer = new Buffer(12);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '460000000704746573746231');
		assert.strictEqual(buffer.used, 12);
		},
		'should serialize {type:\'Void\',data:undefined}' : function(serialize) {
		var value = {
		type : 'Void',
		data : undefined
		};
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '56');
		assert.strictEqual(buffer.used, 1);
		},
		'should serialize {type:\'Byte array\',data:new Buffer([0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef])}' : function(serialize) {
		var value = {
		type : 'Byte array',
		data : new Buffer([ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef ])
		};
		var buffer = new Buffer(13);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '78000000080123456789abcdef');
		assert.strictEqual(buffer.used, 13);
		},
		'should serialize undefined' : function(serialize) {
		var value = undefined;
		var buffer = new Buffer(1);
		buffer.used = 0;
		serialize(buffer, value);
		assert.strictEqual(buffer.toString('hex'), '56');
		assert.strictEqual(buffer.used, 1);
		}
		}
		}
		}).export(module);

test/specification-test.js

		@@ -10,35 +10,32 @@ var vows = require('vows');

		vows
		.describe('specification')
		.addBatch(
		{
		'The RabbitMQ 0-9-1-extended specification' : {
		topic : function() {
		var self = this;
		specification.selectSpecification('rabbitmq/full/amqp0-9-1.stripped.extended', function() {
		specification.getSpecification(function(spec) {
		self.callback(null, spec);
		});
		});
		},
		'path' : {
		topic : function(spec) {
		return spec.path
		},
		'should match the specification source' : function(path) {
		var sourcePath = 'rabbitmq/full/amqp0-9-1.stripped.extended';
		assert.strictEqual(path, sourcePath);
		}
		},
		'amqp version' : {
		topic : function(spec) {
		return spec.amqp
		},
		'should be 0-9-1' : function(version) {
		assert.strictEqual(version.major, '0');
		assert.strictEqual(version.minor, '9');
		assert.strictEqual(version.revision, '1');
		}
		}
		}
		}).export(module);
		vows.describe('specification').addBatch({
		'The RabbitMQ 0-9-1-extended specification' : {
		topic : function() {
		var self = this;
		specification.selectSpecification('rabbitmq/full/amqp0-9-1.stripped.extended', function() {
		specification.getSpecification(function(spec) {
		self.callback(null, spec);
		});
		});
		},
		'path' : {
		topic : function(spec) {
		return spec.path;
		},
		'should match the specification source' : function(path) {
		var sourcePath = 'rabbitmq/full/amqp0-9-1.stripped.extended';
		assert.strictEqual(path, sourcePath);
		}
		},
		'amqp version' : {
		topic : function(spec) {
		return spec.amqp;
		},
		'should be 0-9-1' : function(version) {
		assert.strictEqual(version.major, '0');
		assert.strictEqual(version.minor, '9');
		assert.strictEqual(version.revision, '1');
		}
		}
		}
		}).export(module);

tutorial/3 Publish Subscribe/consumer.js

		@@ -11,3 +11,3 @@ var bramqp = require('bramqp');
		var exchangeType = 'fanout';
		var queueName = "";
		var queueName = '';
		var socket = net.connect({
		@@ -14,0 +14,0 @@ port : 5672

tutorial/3 Publish Subscribe/producer.js

		@@ -40,5 +40,5 @@ var bramqp = require('bramqp');
		var properties = {};
		var content = "11-23-2013: some log";
		var content = '11-23-2013: some log';
		handle.content(1, contentType, properties, content, function() {
		console.log("message published");
		console.log('message published');
		seriesCallback();
		@@ -49,3 +49,3 @@ });
		handle.on('basic.return', function(replyCode, replyText, exchange, routingKey) {
		console.log("Message Returned from Server");
		console.log('Message Returned from Server');
		console.log(replyCode);
		@@ -58,7 +58,7 @@ console.log(replyText);
		setTimeout(function() {
		console.log("close communication");
		console.log('close communication');
		handle.closeAMQPCommunication(seriesCallback);
		}, 10 * 1000);
		}, function(seriesCallback) {
		console.log("socket ended");
		console.log('socket ended');
		handle.socket.end();
		@@ -65,0 +65,0 @@ setImmediate(seriesCallback);

tutorial/6 RPC/rpc_client.js

		@@ -80,7 +80,7 @@ var bramqp = require('bramqp');
		var fibonacciRpc = new FibonacciRpcClient(function() {
		console.log(" [x] Requesting fib(30)");
		console.log(' [x] Requesting fib(30)');
		fibonacciRpc.call(30, function(response) {
		console.log(" [.] Got " + response);
		console.log(' [.] Got ' + response);
		});

		});

tutorial/6 RPC/rpc_server.js

		@@ -51,3 +51,3 @@ var bramqp = require('bramqp');
		var n = parseInt(content.toString(), 10);
		console.log(" [.] fib(" + n + ")");
		console.log(' [.] fib(' + n + ')');
		var response = fib(n);
		@@ -54,0 +54,0 @@ handle.basic.publish(1, '', properties['reply-to'], false, false, function() {

.npmignore

.travis.yml

Sorry, the diff of this file is not supported yet

Improved metrics

Worsened metrics

Dependency changes