embeditor-rails 1.1.1 → 2.0.0.beta

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctio/int/tst.rint.js

@@ -0,0 +1,101 @@
+/*
+ * Tests to verify we're reading in signed integers correctly
+ */
+var mod_ctype = require('../../../ctio.js');
+var ASSERT = require('assert');
+
+/*
+ * Test 8 bit signed integers
+ */
+function test8()
+{
+	var data = new Buffer(4);
+
+	data[0] = 0x23;
+	ASSERT.equal(0x23, mod_ctype.rsint8(data, 'big', 0));
+	ASSERT.equal(0x23, mod_ctype.rsint8(data, 'little', 0));
+
+	data[0] = 0xff;
+	ASSERT.equal(-1, mod_ctype.rsint8(data, 'big', 0));
+	ASSERT.equal(-1, mod_ctype.rsint8(data, 'little', 0));
+
+	data[0] = 0x87;
+	data[1] = 0xab;
+	data[2] = 0x7c;
+	data[3] = 0xef;
+	ASSERT.equal(-121, mod_ctype.rsint8(data, 'big', 0));
+	ASSERT.equal(-85, mod_ctype.rsint8(data, 'big', 1));
+	ASSERT.equal(124, mod_ctype.rsint8(data, 'big', 2));
+	ASSERT.equal(-17, mod_ctype.rsint8(data, 'big', 3));
+	ASSERT.equal(-121, mod_ctype.rsint8(data, 'little', 0));
+	ASSERT.equal(-85, mod_ctype.rsint8(data, 'little', 1));
+	ASSERT.equal(124, mod_ctype.rsint8(data, 'little', 2));
+	ASSERT.equal(-17, mod_ctype.rsint8(data, 'little', 3));
+}
+
+function test16()
+{
+	var buffer = new Buffer(6);
+	buffer[0] = 0x16;
+	buffer[1] = 0x79;
+	ASSERT.equal(0x1679, mod_ctype.rsint16(buffer, 'big', 0));
+	ASSERT.equal(0x7916, mod_ctype.rsint16(buffer, 'little', 0));
+
+	buffer[0] = 0xff;
+	buffer[1] = 0x80;
+	ASSERT.equal(-128, mod_ctype.rsint16(buffer, 'big', 0));
+	ASSERT.equal(-32513, mod_ctype.rsint16(buffer, 'little', 0));
+
+	/* test offset with weenix */
+	buffer[0] = 0x77;
+	buffer[1] = 0x65;
+	buffer[2] = 0x65;
+	buffer[3] = 0x6e;
+	buffer[4] = 0x69;
+	buffer[5] = 0x78;
+	ASSERT.equal(0x7765, mod_ctype.rsint16(buffer, 'big', 0));
+	ASSERT.equal(0x6565, mod_ctype.rsint16(buffer, 'big', 1));
+	ASSERT.equal(0x656e, mod_ctype.rsint16(buffer, 'big', 2));
+	ASSERT.equal(0x6e69, mod_ctype.rsint16(buffer, 'big', 3));
+	ASSERT.equal(0x6978, mod_ctype.rsint16(buffer, 'big', 4));
+	ASSERT.equal(0x6577, mod_ctype.rsint16(buffer, 'little', 0));
+	ASSERT.equal(0x6565, mod_ctype.rsint16(buffer, 'little', 1));
+	ASSERT.equal(0x6e65, mod_ctype.rsint16(buffer, 'little', 2));
+	ASSERT.equal(0x696e, mod_ctype.rsint16(buffer, 'little', 3));
+	ASSERT.equal(0x7869, mod_ctype.rsint16(buffer, 'little', 4));
+}
+
+function test32()
+{
+	var buffer = new Buffer(6);
+	buffer[0] = 0x43;
+	buffer[1] = 0x53;
+	buffer[2] = 0x16;
+	buffer[3] = 0x79;
+	ASSERT.equal(0x43531679, mod_ctype.rsint32(buffer, 'big', 0));
+	ASSERT.equal(0x79165343, mod_ctype.rsint32(buffer, 'little', 0));
+
+	buffer[0] = 0xff;
+	buffer[1] = 0xfe;
+	buffer[2] = 0xef;
+	buffer[3] = 0xfa;
+	ASSERT.equal(-69638, mod_ctype.rsint32(buffer, 'big', 0));
+	ASSERT.equal(-84934913, mod_ctype.rsint32(buffer, 'little', 0));
+
+	buffer[0] = 0x42;
+	buffer[1] = 0xc3;
+	buffer[2] = 0x95;
+	buffer[3] = 0xa9;
+	buffer[4] = 0x36;
+	buffer[5] = 0x17;
+	ASSERT.equal(0x42c395a9, mod_ctype.rsint32(buffer, 'big', 0));
+	ASSERT.equal(-1013601994, mod_ctype.rsint32(buffer, 'big', 1));
+	ASSERT.equal(-1784072681, mod_ctype.rsint32(buffer, 'big', 2));
+	ASSERT.equal(-1449802942, mod_ctype.rsint32(buffer, 'little', 0));
+	ASSERT.equal(917083587, mod_ctype.rsint32(buffer, 'little', 1));
+	ASSERT.equal(389458325, mod_ctype.rsint32(buffer, 'little', 2));
+}
+
+test8();
+test16();
+test32();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctio/int/tst.wbounds.js

@@ -0,0 +1,53 @@
+/*
+ * Test to make sure that we properly are erroring whenever we try to write
+ * beyond the size of the integer.
+ */
+
+var mod_ctio = require('../../../ctio.js');
+var mod_assert = require('assert');
+var tb = new Buffer(16); /* Largest buffer we'll need */
+
+var cases = [
+	{ func:
+	function () {
+		mod_ctio.wsint8(0x80, 'big', tb, 0);
+	}, test: '+int8_t' },
+	{ func:
+	function () {
+		mod_ctio.wsint8(-0x81, 'big', tb, 0);
+	}, test: '-int8_t' },
+
+	{ func:
+	function () {
+		mod_ctio.wsint16(0x8000, 'big', tb, 0);
+	}, test: '+int16_t' },
+	{ func:
+	function () {
+		mod_ctio.wsint16(-0x8001, 'big', tb, 0);
+	}, test: '-int16_t' },
+	{ func:
+	function () {
+		mod_ctio.wsint32(0x80000000, 'big', tb, 0);
+	}, test: '+int32_t' },
+	{ func:
+	function () {
+		mod_ctio.wsint32(-0x80000001, 'big', tb, 0);
+	}, test: '-int32_t' },
+	{ func:
+	function () {
+		mod_ctio.wsint64([ 0x80000000, 0 ], 'big', tb, 0);
+	}, test: '+int64_t' },
+	{ func:
+	function () {
+		mod_ctio.wsint64([ -0x80000000, -1 ], 'big', tb, 0);
+	}, test: '-int64_t' }
+];
+
+function test()
+{
+	var ii;
+	for (ii = 0; ii < cases.length; ii++)
+		mod_assert.throws(cases[ii]['func'], Error, cases[ii]['test']);
+}
+
+test();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctio/int/tst.wint.js

@@ -0,0 +1,92 @@
+/*
+ * Tests to verify we're writing signed integers correctly
+ */
+var mod_ctype = require('../../../ctio.js');
+var ASSERT = require('assert');
+
+function test8()
+{
+	var buffer = new Buffer(4);
+	mod_ctype.wsint8(0x23, 'big', buffer, 0);
+	mod_ctype.wsint8(0x23, 'little', buffer, 1);
+	mod_ctype.wsint8(-5, 'big', buffer, 2);
+	mod_ctype.wsint8(-5, 'little', buffer, 3);
+
+	ASSERT.equal(0x23, buffer[0]);
+	ASSERT.equal(0x23, buffer[1]);
+	ASSERT.equal(0xfb, buffer[2]);
+	ASSERT.equal(0xfb, buffer[3]);
+
+	/* Make sure we handle truncation correctly */
+	ASSERT.throws(function () {
+	     mod_ctype.wsint8(0xabc, 'big', buffer, 0);
+	});
+	ASSERT.throws(function () {
+	     mod_ctype.wsint8(0xabc, 'little', buffer, 0);
+	});
+}
+
+function test16()
+{
+	var buffer = new Buffer(6);
+	mod_ctype.wsint16(0x0023, 'big', buffer, 0);
+	mod_ctype.wsint16(0x0023, 'little', buffer, 2);
+	ASSERT.equal(0x00, buffer[0]);
+	ASSERT.equal(0x23, buffer[1]);
+	ASSERT.equal(0x23, buffer[2]);
+	ASSERT.equal(0x00, buffer[3]);
+	mod_ctype.wsint16(-5, 'big', buffer, 0);
+	mod_ctype.wsint16(-5, 'little', buffer, 2);
+	ASSERT.equal(0xff, buffer[0]);
+	ASSERT.equal(0xfb, buffer[1]);
+	ASSERT.equal(0xfb, buffer[2]);
+	ASSERT.equal(0xff, buffer[3]);
+
+	mod_ctype.wsint16(-1679, 'big', buffer, 1);
+	mod_ctype.wsint16(-1679, 'little', buffer, 3);
+	ASSERT.equal(0xf9, buffer[1]);
+	ASSERT.equal(0x71, buffer[2]);
+	ASSERT.equal(0x71, buffer[3]);
+	ASSERT.equal(0xf9, buffer[4]);
+}
+
+function test32()
+{
+	var buffer = new Buffer(8);
+	mod_ctype.wsint32(0x23, 'big', buffer, 0);
+	mod_ctype.wsint32(0x23, 'little', buffer, 4);
+	ASSERT.equal(0x00, buffer[0]);
+	ASSERT.equal(0x00, buffer[1]);
+	ASSERT.equal(0x00, buffer[2]);
+	ASSERT.equal(0x23, buffer[3]);
+	ASSERT.equal(0x23, buffer[4]);
+	ASSERT.equal(0x00, buffer[5]);
+	ASSERT.equal(0x00, buffer[6]);
+	ASSERT.equal(0x00, buffer[7]);
+
+	mod_ctype.wsint32(-5, 'big', buffer, 0);
+	mod_ctype.wsint32(-5, 'little', buffer, 4);
+	ASSERT.equal(0xff, buffer[0]);
+	ASSERT.equal(0xff, buffer[1]);
+	ASSERT.equal(0xff, buffer[2]);
+	ASSERT.equal(0xfb, buffer[3]);
+	ASSERT.equal(0xfb, buffer[4]);
+	ASSERT.equal(0xff, buffer[5]);
+	ASSERT.equal(0xff, buffer[6]);
+	ASSERT.equal(0xff, buffer[7]);
+
+	mod_ctype.wsint32(-805306713, 'big', buffer, 0);
+	mod_ctype.wsint32(-805306713, 'litle', buffer, 4);
+	ASSERT.equal(0xcf, buffer[0]);
+	ASSERT.equal(0xff, buffer[1]);
+	ASSERT.equal(0xfe, buffer[2]);
+	ASSERT.equal(0xa7, buffer[3]);
+	ASSERT.equal(0xa7, buffer[4]);
+	ASSERT.equal(0xfe, buffer[5]);
+	ASSERT.equal(0xff, buffer[6]);
+	ASSERT.equal(0xcf, buffer[7]);
+}
+
+test8();
+test16();
+test32();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctio/uint/tst.64.js

@@ -0,0 +1,451 @@
+/*
+ * Test our ability to read and write unsigned 64-bit integers.
+ */
+
+var mod_ctype = require('../../../ctio.js');
+var ASSERT = require('assert');
+
+function testRead()
+{
+	var res, data;
+	data = new Buffer(10);
+
+	data[0] = 0x32;
+	data[1] = 0x65;
+	data[2] = 0x42;
+	data[3] = 0x56;
+	data[4] = 0x23;
+	data[5] = 0xff;
+	data[6] = 0xff;
+	data[7] = 0xff;
+	data[8] = 0x89;
+	data[9] = 0x11;
+	res = mod_ctype.ruint64(data, 'big', 0);
+	ASSERT.equal(0x32654256, res[0]);
+	ASSERT.equal(0x23ffffff, res[1]);
+	res = mod_ctype.ruint64(data, 'big', 1);
+	ASSERT.equal(0x65425623, res[0]);
+	ASSERT.equal(0xffffff89, res[1]);
+	res = mod_ctype.ruint64(data, 'big', 2);
+	ASSERT.equal(0x425623ff, res[0]);
+	ASSERT.equal(0xffff8911, res[1]);
+	res = mod_ctype.ruint64(data, 'little', 0);
+	ASSERT.equal(0xffffff23, res[0]);
+	ASSERT.equal(0x56426532, res[1]);
+	res = mod_ctype.ruint64(data, 'little', 1);
+	ASSERT.equal(0x89ffffff, res[0]);
+	ASSERT.equal(0x23564265, res[1]);
+	res = mod_ctype.ruint64(data, 'little', 2);
+	ASSERT.equal(0x1189ffff, res[0]);
+	ASSERT.equal(0xff235642, res[1]);
+
+}
+
+function testReadOver()
+{
+	var res, data;
+	data = new Buffer(10);
+
+	data[0] = 0x80;
+	data[1] = 0xff;
+	data[2] = 0x80;
+	data[3] = 0xff;
+	data[4] = 0x80;
+	data[5] = 0xff;
+	data[6] = 0x80;
+	data[7] = 0xff;
+	data[8] = 0x80;
+	data[9] = 0xff;
+	res = mod_ctype.ruint64(data, 'big', 0);
+	ASSERT.equal(0x80ff80ff, res[0]);
+	ASSERT.equal(0x80ff80ff, res[1]);
+	res = mod_ctype.ruint64(data, 'big', 1);
+	ASSERT.equal(0xff80ff80, res[0]);
+	ASSERT.equal(0xff80ff80, res[1]);
+	res = mod_ctype.ruint64(data, 'big', 2);
+	ASSERT.equal(0x80ff80ff, res[0]);
+	ASSERT.equal(0x80ff80ff, res[1]);
+	res = mod_ctype.ruint64(data, 'little', 0);
+	ASSERT.equal(0xff80ff80, res[0]);
+	ASSERT.equal(0xff80ff80, res[1]);
+	res = mod_ctype.ruint64(data, 'little', 1);
+	ASSERT.equal(0x80ff80ff, res[0]);
+	ASSERT.equal(0x80ff80ff, res[1]);
+	res = mod_ctype.ruint64(data, 'little', 2);
+	ASSERT.equal(0xff80ff80, res[0]);
+	ASSERT.equal(0xff80ff80, res[1]);
+}
+
+function testWriteZero()
+{
+	var data, buf;
+	buf = new Buffer(10);
+
+	buf.fill(0x66);
+	data = [0, 0];
+	mod_ctype.wuint64(data, 'big', buf, 0);
+	ASSERT.equal(0, buf[0]);
+	ASSERT.equal(0, buf[1]);
+	ASSERT.equal(0, buf[2]);
+	ASSERT.equal(0, buf[3]);
+	ASSERT.equal(0, buf[4]);
+	ASSERT.equal(0, buf[5]);
+	ASSERT.equal(0, buf[6]);
+	ASSERT.equal(0, buf[7]);
+	ASSERT.equal(0x66, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	data = [0, 0];
+	mod_ctype.wuint64(data, 'big', buf, 1);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0, buf[1]);
+	ASSERT.equal(0, buf[2]);
+	ASSERT.equal(0, buf[3]);
+	ASSERT.equal(0, buf[4]);
+	ASSERT.equal(0, buf[5]);
+	ASSERT.equal(0, buf[6]);
+	ASSERT.equal(0, buf[7]);
+	ASSERT.equal(0, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	data = [0, 0];
+	mod_ctype.wuint64(data, 'big', buf, 2);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x66, buf[1]);
+	ASSERT.equal(0, buf[2]);
+	ASSERT.equal(0, buf[3]);
+	ASSERT.equal(0, buf[4]);
+	ASSERT.equal(0, buf[5]);
+	ASSERT.equal(0, buf[6]);
+	ASSERT.equal(0, buf[7]);
+	ASSERT.equal(0, buf[8]);
+	ASSERT.equal(0, buf[9]);
+
+
+	buf.fill(0x66);
+	data = [0, 0];
+	mod_ctype.wuint64(data, 'little', buf, 0);
+	ASSERT.equal(0, buf[0]);
+	ASSERT.equal(0, buf[1]);
+	ASSERT.equal(0, buf[2]);
+	ASSERT.equal(0, buf[3]);
+	ASSERT.equal(0, buf[4]);
+	ASSERT.equal(0, buf[5]);
+	ASSERT.equal(0, buf[6]);
+	ASSERT.equal(0, buf[7]);
+	ASSERT.equal(0x66, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	data = [0, 0];
+	mod_ctype.wuint64(data, 'little', buf, 1);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0, buf[1]);
+	ASSERT.equal(0, buf[2]);
+	ASSERT.equal(0, buf[3]);
+	ASSERT.equal(0, buf[4]);
+	ASSERT.equal(0, buf[5]);
+	ASSERT.equal(0, buf[6]);
+	ASSERT.equal(0, buf[7]);
+	ASSERT.equal(0, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	data = [0, 0];
+	mod_ctype.wuint64(data, 'little', buf, 2);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x66, buf[1]);
+	ASSERT.equal(0, buf[2]);
+	ASSERT.equal(0, buf[3]);
+	ASSERT.equal(0, buf[4]);
+	ASSERT.equal(0, buf[5]);
+	ASSERT.equal(0, buf[6]);
+	ASSERT.equal(0, buf[7]);
+	ASSERT.equal(0, buf[8]);
+	ASSERT.equal(0, buf[9]);
+}
+
+/*
+ * Also include tests that are going to force us to go into a negative value and
+ * insure that it's written correctly.
+ */
+function testWrite()
+{
+	var data, buf;
+
+	buf = new Buffer(10);
+	data = [ 0x234456, 0x87 ];
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'big', buf, 0);
+	ASSERT.equal(0x00, buf[0]);
+	ASSERT.equal(0x23, buf[1]);
+	ASSERT.equal(0x44, buf[2]);
+	ASSERT.equal(0x56, buf[3]);
+	ASSERT.equal(0x00, buf[4]);
+	ASSERT.equal(0x00, buf[5]);
+	ASSERT.equal(0x00, buf[6]);
+	ASSERT.equal(0x87, buf[7]);
+	ASSERT.equal(0x66, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'big', buf, 1);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x00, buf[1]);
+	ASSERT.equal(0x23, buf[2]);
+	ASSERT.equal(0x44, buf[3]);
+	ASSERT.equal(0x56, buf[4]);
+	ASSERT.equal(0x00, buf[5]);
+	ASSERT.equal(0x00, buf[6]);
+	ASSERT.equal(0x00, buf[7]);
+	ASSERT.equal(0x87, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'big', buf, 2);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x66, buf[1]);
+	ASSERT.equal(0x00, buf[2]);
+	ASSERT.equal(0x23, buf[3]);
+	ASSERT.equal(0x44, buf[4]);
+	ASSERT.equal(0x56, buf[5]);
+	ASSERT.equal(0x00, buf[6]);
+	ASSERT.equal(0x00, buf[7]);
+	ASSERT.equal(0x00, buf[8]);
+	ASSERT.equal(0x87, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'little', buf, 0);
+	ASSERT.equal(0x87, buf[0]);
+	ASSERT.equal(0x00, buf[1]);
+	ASSERT.equal(0x00, buf[2]);
+	ASSERT.equal(0x00, buf[3]);
+	ASSERT.equal(0x56, buf[4]);
+	ASSERT.equal(0x44, buf[5]);
+	ASSERT.equal(0x23, buf[6]);
+	ASSERT.equal(0x00, buf[7]);
+	ASSERT.equal(0x66, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'little', buf, 1);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x87, buf[1]);
+	ASSERT.equal(0x00, buf[2]);
+	ASSERT.equal(0x00, buf[3]);
+	ASSERT.equal(0x00, buf[4]);
+	ASSERT.equal(0x56, buf[5]);
+	ASSERT.equal(0x44, buf[6]);
+	ASSERT.equal(0x23, buf[7]);
+	ASSERT.equal(0x00, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'little', buf, 2);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x66, buf[1]);
+	ASSERT.equal(0x87, buf[2]);
+	ASSERT.equal(0x00, buf[3]);
+	ASSERT.equal(0x00, buf[4]);
+	ASSERT.equal(0x00, buf[5]);
+	ASSERT.equal(0x56, buf[6]);
+	ASSERT.equal(0x44, buf[7]);
+	ASSERT.equal(0x23, buf[8]);
+	ASSERT.equal(0x00, buf[9]);
+
+	data = [0xffff3421, 0x34abcdba];
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'big', buf, 0);
+	ASSERT.equal(0xff, buf[0]);
+	ASSERT.equal(0xff, buf[1]);
+	ASSERT.equal(0x34, buf[2]);
+	ASSERT.equal(0x21, buf[3]);
+	ASSERT.equal(0x34, buf[4]);
+	ASSERT.equal(0xab, buf[5]);
+	ASSERT.equal(0xcd, buf[6]);
+	ASSERT.equal(0xba, buf[7]);
+	ASSERT.equal(0x66, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'big', buf, 1);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0xff, buf[1]);
+	ASSERT.equal(0xff, buf[2]);
+	ASSERT.equal(0x34, buf[3]);
+	ASSERT.equal(0x21, buf[4]);
+	ASSERT.equal(0x34, buf[5]);
+	ASSERT.equal(0xab, buf[6]);
+	ASSERT.equal(0xcd, buf[7]);
+	ASSERT.equal(0xba, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'big', buf, 2);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x66, buf[1]);
+	ASSERT.equal(0xff, buf[2]);
+	ASSERT.equal(0xff, buf[3]);
+	ASSERT.equal(0x34, buf[4]);
+	ASSERT.equal(0x21, buf[5]);
+	ASSERT.equal(0x34, buf[6]);
+	ASSERT.equal(0xab, buf[7]);
+	ASSERT.equal(0xcd, buf[8]);
+	ASSERT.equal(0xba, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'little', buf, 0);
+	ASSERT.equal(0xba, buf[0]);
+	ASSERT.equal(0xcd, buf[1]);
+	ASSERT.equal(0xab, buf[2]);
+	ASSERT.equal(0x34, buf[3]);
+	ASSERT.equal(0x21, buf[4]);
+	ASSERT.equal(0x34, buf[5]);
+	ASSERT.equal(0xff, buf[6]);
+	ASSERT.equal(0xff, buf[7]);
+	ASSERT.equal(0x66, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'little', buf, 1);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0xba, buf[1]);
+	ASSERT.equal(0xcd, buf[2]);
+	ASSERT.equal(0xab, buf[3]);
+	ASSERT.equal(0x34, buf[4]);
+	ASSERT.equal(0x21, buf[5]);
+	ASSERT.equal(0x34, buf[6]);
+	ASSERT.equal(0xff, buf[7]);
+	ASSERT.equal(0xff, buf[8]);
+	ASSERT.equal(0x66, buf[9]);
+
+	buf.fill(0x66);
+	mod_ctype.wuint64(data, 'little', buf, 2);
+	ASSERT.equal(0x66, buf[0]);
+	ASSERT.equal(0x66, buf[1]);
+	ASSERT.equal(0xba, buf[2]);
+	ASSERT.equal(0xcd, buf[3]);
+	ASSERT.equal(0xab, buf[4]);
+	ASSERT.equal(0x34, buf[5]);
+	ASSERT.equal(0x21, buf[6]);
+	ASSERT.equal(0x34, buf[7]);
+	ASSERT.equal(0xff, buf[8]);
+	ASSERT.equal(0xff, buf[9]);
+}
+
+/*
+ * Make sure we catch invalid writes.
+ */
+function testWriteInvalid()
+{
+	var data, buf;
+
+	/* Buffer too small */
+	buf = new Buffer(4);
+	data = [ 0, 0];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 0);
+	}, Error, 'buffer too small');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 0);
+	}, Error, 'buffer too small');
+
+	/* Beyond the end of the buffer */
+	buf = new Buffer(12);
+	data = [ 0, 0];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 11);
+	}, Error, 'write beyond end of buffer');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 11);
+	}, Error, 'write beyond end of buffer');
+
+	/* Write negative values */
+	buf = new Buffer(12);
+	data = [ -3, 0 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write negative number');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write negative number');
+
+	data = [ 0, -3 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write negative number');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write negative number');
+
+	data = [ -3, -3 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write negative number');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write negative number');
+
+
+	/* Write fractional values */
+	buf = new Buffer(12);
+	data = [ 3.33, 0 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write fractions');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write fractions');
+
+	data = [ 0, 3.3 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write fractions');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write fractions');
+
+	data = [ 3.33, 2.42 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write fractions');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write fractions');
+
+	/* Write values that are too large */
+	buf = new Buffer(12);
+	data = [ 0xffffffffff, 23 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write too large');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write too large');
+
+	data = [ 0xffffffffff, 0xffffff238 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write too large');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write too large');
+
+	data = [ 0x23, 0xffffff238 ];
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'big', buf, 1);
+	}, Error, 'write too large');
+	ASSERT.throws(function () {
+	    mod_ctype.wuint64(data, 'little', buf, 1);
+	}, Error, 'write too large');
+}
+
+
+testRead();
+testReadOver();
+testWriteZero();
+testWrite();
+testWriteInvalid();