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/ctf/float.json

@@ -0,0 +1,13 @@
+{ "metadata":
+	{
+		"ctf2json_version": "1.0",
+		"created_at": 1316563626,
+		"derived_from": "/lib/libc.so",
+		"ctf_version": 2,
+		"requested_types": [ "float" ]
+	},
+"data":
+	[
+		{ "name": "float", "float": { "length": 4 } }
+	]
+}

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/int.json

@@ -0,0 +1,13 @@
+{ "metadata":
+	{
+		"ctf2json_version": "1.0",
+		"created_at": 1316563631,
+		"derived_from": "/lib/libc.so",
+		"ctf_version": 2,
+		"requested_types": [ "int" ]
+	},
+"data":
+	[
+		{ "name": "int", "integer": { "length": 4, "signed": true } }
+	]
+}

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/psinfo.json

@@ -0,0 +1,104 @@
+{ "metadata":
+	{
+		"ctf2json_version": "1.0",
+		"created_at": 1316563573,
+		"derived_from": "/lib/libc.so",
+		"ctf_version": 2,
+		"requested_types": [ "psinfo_t" ]
+	},
+"data":
+	[
+		{ "name": "int", "integer": { "length": 4, "signed": true } },
+		{ "name": "char", "integer": { "length": 1, "signed": true } },
+		{ "name": "unsigned short", "integer": { "length": 2, "signed": false } },
+		{ "name": "long", "integer": { "length": 4, "signed": true } },
+		{ "name": "unsigned", "integer": { "length": 4, "signed": false } },
+		{ "name": "size_t", "typedef": "unsigned" },
+		{ "name": "unsigned long", "integer": { "length": 4, "signed": false } },
+		{ "name": "time_t", "typedef": "long" },
+		{ "name": "struct timespec", "struct": [
+			{ "name": "tv_sec", "type": "time_t" },
+			{ "name": "tv_nsec", "type": "long" }
+		] },
+		{ "name": "zoneid_t", "typedef": "long" },
+		{ "name": "taskid_t", "typedef": "long" },
+		{ "name": "dev_t", "typedef": "unsigned long" },
+		{ "name": "uid_t", "typedef": "unsigned" },
+		{ "name": "gid_t", "typedef": "unsigned" },
+		{ "name": "timestruc_t", "typedef": "struct timespec" },
+		{ "name": "short", "integer": { "length": 2, "signed": true } },
+		{ "name": "projid_t", "typedef": "long" },
+		{ "name": "ushort_t", "typedef": "unsigned short" },
+		{ "name": "poolid_t", "typedef": "long" },
+		{ "name": "uintptr_t", "typedef": "unsigned" },
+		{ "name": "id_t", "typedef": "long" },
+		{ "name": "pid_t", "typedef": "long" },
+		{ "name": "processorid_t", "typedef": "int" },
+		{ "name": "psetid_t", "typedef": "int" },
+		{ "name": "struct lwpsinfo", "struct": [
+			{ "name": "pr_flag", "type": "int" },
+			{ "name": "pr_lwpid", "type": "id_t" },
+			{ "name": "pr_addr", "type": "uintptr_t" },
+			{ "name": "pr_wchan", "type": "uintptr_t" },
+			{ "name": "pr_stype", "type": "char" },
+			{ "name": "pr_state", "type": "char" },
+			{ "name": "pr_sname", "type": "char" },
+			{ "name": "pr_nice", "type": "char" },
+			{ "name": "pr_syscall", "type": "short" },
+			{ "name": "pr_oldpri", "type": "char" },
+			{ "name": "pr_cpu", "type": "char" },
+			{ "name": "pr_pri", "type": "int" },
+			{ "name": "pr_pctcpu", "type": "ushort_t" },
+			{ "name": "pr_pad", "type": "ushort_t" },
+			{ "name": "pr_start", "type": "timestruc_t" },
+			{ "name": "pr_time", "type": "timestruc_t" },
+			{ "name": "pr_clname", "type": "char [8]" },
+			{ "name": "pr_name", "type": "char [16]" },
+			{ "name": "pr_onpro", "type": "processorid_t" },
+			{ "name": "pr_bindpro", "type": "processorid_t" },
+			{ "name": "pr_bindpset", "type": "psetid_t" },
+			{ "name": "pr_lgrp", "type": "int" },
+			{ "name": "pr_filler", "type": "int [4]" }
+		] },
+		{ "name": "lwpsinfo_t", "typedef": "struct lwpsinfo" },
+		{ "name": "struct psinfo", "struct": [
+			{ "name": "pr_flag", "type": "int" },
+			{ "name": "pr_nlwp", "type": "int" },
+			{ "name": "pr_pid", "type": "pid_t" },
+			{ "name": "pr_ppid", "type": "pid_t" },
+			{ "name": "pr_pgid", "type": "pid_t" },
+			{ "name": "pr_sid", "type": "pid_t" },
+			{ "name": "pr_uid", "type": "uid_t" },
+			{ "name": "pr_euid", "type": "uid_t" },
+			{ "name": "pr_gid", "type": "gid_t" },
+			{ "name": "pr_egid", "type": "gid_t" },
+			{ "name": "pr_addr", "type": "uintptr_t" },
+			{ "name": "pr_size", "type": "size_t" },
+			{ "name": "pr_rssize", "type": "size_t" },
+			{ "name": "pr_pad1", "type": "size_t" },
+			{ "name": "pr_ttydev", "type": "dev_t" },
+			{ "name": "pr_pctcpu", "type": "ushort_t" },
+			{ "name": "pr_pctmem", "type": "ushort_t" },
+			{ "name": "pr_start", "type": "timestruc_t" },
+			{ "name": "pr_time", "type": "timestruc_t" },
+			{ "name": "pr_ctime", "type": "timestruc_t" },
+			{ "name": "pr_fname", "type": "char [16]" },
+			{ "name": "pr_psargs", "type": "char [80]" },
+			{ "name": "pr_wstat", "type": "int" },
+			{ "name": "pr_argc", "type": "int" },
+			{ "name": "pr_argv", "type": "uintptr_t" },
+			{ "name": "pr_envp", "type": "uintptr_t" },
+			{ "name": "pr_dmodel", "type": "char" },
+			{ "name": "pr_pad2", "type": "char [3]" },
+			{ "name": "pr_taskid", "type": "taskid_t" },
+			{ "name": "pr_projid", "type": "projid_t" },
+			{ "name": "pr_nzomb", "type": "int" },
+			{ "name": "pr_poolid", "type": "poolid_t" },
+			{ "name": "pr_zoneid", "type": "zoneid_t" },
+			{ "name": "pr_contract", "type": "id_t" },
+			{ "name": "pr_filler", "type": "int [1]" },
+			{ "name": "pr_lwp", "type": "lwpsinfo_t" }
+		] },
+		{ "name": "psinfo_t", "typedef": "struct psinfo" }
+	]
+}

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/struct.json

@@ -0,0 +1,19 @@
+{ "metadata":
+	{
+		"ctf2json_version": "1.0",
+		"created_at": 1316563648,
+		"derived_from": "/lib/libc.so",
+		"ctf_version": 2,
+		"requested_types": [ "timestruc_t" ]
+	},
+"data":
+	[
+		{ "name": "long", "integer": { "length": 4, "signed": true } },
+		{ "name": "time_t", "typedef": "long" },
+		{ "name": "struct timespec", "struct": [
+			{ "name": "tv_sec", "type": "time_t" },
+			{ "name": "tv_nsec", "type": "long" }
+		] },
+		{ "name": "timestruc_t", "typedef": "struct timespec" }
+	]
+}

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/tst.fail.js

@@ -0,0 +1,39 @@
+/*
+ * Test several conditions that should always cause us to throw.
+ */
+var mod_assert = require('assert');
+var mod_ctype = require('../../ctype.js');
+
+var cases = [
+{ json: { }, msg: 'bad JSON - no metadata or data' },
+{ json: { metadata: {} }, msg: 'bad JSON - bad metadata section' },
+{ json: { metadata: { 'JSON version': [] } },
+    msg: 'bad JSON - bad JSON version' },
+{ json: { metadata: { 'JSON version': 2 } },
+    msg: 'bad JSON - bad JSON version' },
+{ json: { metadata: { 'JSON version': '100.20' } },
+    msg: 'bad JSON - bad JSON version' },
+{ json: { metadata: { 'JSON version': '1.0' } },
+    msg: 'missing data section' },
+{ json: { metadata: { 'JSON version': '1.0' }, data: 1 },
+    msg: 'invalid data section' },
+{ json: { metadata: { 'JSON version': '1.0' }, data: 1.1 },
+    msg: 'invalid data section' },
+{ json: { metadata: { 'JSON version': '1.0' }, data: '1.1' },
+    msg: 'invalid data section' },
+{ json: { metadata: { 'JSON version': '1.0' }, data: {} },
+    msg: 'invalid data section' }
+];
+
+function test()
+{
+	var ii;
+
+	for (ii = 0; ii < cases.length; ii++) {
+		mod_assert.throws(function () {
+		    mod_ctype.parseCTF(cases[ii].json);
+		}, Error, cases[ii].msg);
+	}
+}
+
+test();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/tst.float.js

@@ -0,0 +1,14 @@
+var mod_fs = require('fs');
+var mod_ctype = require('../../ctype.js');
+var mod_assert = require('assert');
+
+function test()
+{
+	var data, parser;
+
+	data = JSON.parse(mod_fs.readFileSync('./float.json').toString());
+	parser = mod_ctype.parseCTF(data, { endian: 'big' });
+	mod_assert.deepEqual(parser.lstypes(), {});
+}
+
+test();

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

@@ -0,0 +1,14 @@
+var mod_fs = require('fs');
+var mod_ctype = require('../../ctype.js');
+var mod_assert = require('assert');
+
+function test()
+{
+	var data, parser;
+
+	data = JSON.parse(mod_fs.readFileSync('./int.json').toString());
+	parser = mod_ctype.parseCTF(data, { endian: 'big' });
+	mod_assert.deepEqual(parser.lstypes(), { 'int': 'int32_t' });
+}
+
+test();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/tst.psinfo.js

@@ -0,0 +1,17 @@
+var mod_fs = require('fs');
+var mod_ctype = require('../../ctype.js');
+var mod_assert = require('assert');
+
+/*
+ * This is too unwieldly to actually write out. Just make sure we can parse it
+ * without errrors.
+ */
+function test()
+{
+	var data;
+
+	data = JSON.parse(mod_fs.readFileSync('./psinfo.json').toString());
+	mod_ctype.parseCTF(data, { endian: 'big' });
+}
+
+test();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/tst.struct.js

@@ -0,0 +1,18 @@
+var mod_fs = require('fs');
+var mod_ctype = require('../../ctype.js');
+var mod_assert = require('assert');
+
+function test()
+{
+	var data, parser;
+
+	data = JSON.parse(mod_fs.readFileSync('./struct.json').toString());
+	parser = mod_ctype.parseCTF(data, { endian: 'big' });
+	mod_assert.deepEqual(parser.lstypes(), { 'long': 'int32_t',
+	    'time_t': 'long',
+	    'timestruc_t': 'struct timespec',
+	    'struct timespec': [ { 'tv_sec': { 'type': 'time_t' } },
+	        { 'tv_nsec': { 'type': 'long' } } ] });
+}
+
+test();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/tst.typedef.js

@@ -0,0 +1,15 @@
+var mod_fs = require('fs');
+var mod_ctype = require('../../ctype.js');
+var mod_assert = require('assert');
+
+function test()
+{
+	var data, parser;
+
+	data = JSON.parse(mod_fs.readFileSync('./typedef.json').toString());
+	parser = mod_ctype.parseCTF(data, { endian: 'big' });
+	mod_assert.deepEqual(parser.lstypes(), { 'bar_t': 'int',
+	    'int': 'int32_t' });
+}
+
+test();

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctf/typedef.json

@@ -0,0 +1,14 @@
+{ "metadata":
+	{
+		"ctf2json_version": "1.0",
+		"created_at": 1316302348,
+		"derived_from": "/lib/libc.so",
+		"ctf_version": 2,
+		"requested_types": [ "bar_t" ]
+	},
+"data":
+	[
+		{ "name": "int", "integer": { "length": 4, "signed": true } },
+		{ "name": "bar_t", "typedef": "int" }
+	]
+}

data/lib/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/ctype/tst/ctio/float/tst.rfloat.js

@@ -0,0 +1,767 @@
+/*
+ * Battery of tests to break our floating point implementation. Oh ho ho.
+ *
+ * There are a few useful ways to generate the expected output. The first is
+ * just write a C program and write raw bytes out and inspect with xxd. Remember
+ * to consider whether or not you're on a big endian or little endian machine.
+ * Another useful site I found to help with some of this was:
+ *
+ * http://babbage.cs.qc.edu/IEEE-754/
+ */
+
+var mod_ctype = require('../../../ctio.js');
+var ASSERT = require('assert');
+
+function testfloat()
+{
+	var buffer = new Buffer(4);
+	/* Start off with some of the easy ones: +zero */
+	buffer[0] = 0;
+	buffer[1] = 0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+
+	ASSERT.equal(0, mod_ctype.rfloat(buffer, 'big', 0));
+	ASSERT.equal(0, mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* Test -0 */
+	buffer[0] = 0x80;
+	ASSERT.equal(0, mod_ctype.rfloat(buffer, 'big', 0));
+	buffer[3] = buffer[0];
+	buffer[0] = 0;
+	ASSERT.equal(0, mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* Catch +infin */
+	buffer[0] = 0x7f;
+	buffer[1] = 0x80;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	ASSERT.equal(Number.POSITIVE_INFINITY,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+	buffer[3] = 0x7f;
+	buffer[2] = 0x80;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(Number.POSITIVE_INFINITY,
+	    mod_ctype.rfloat(buffer, 'litle', 0));
+
+	/* Catch -infin */
+	buffer[0] = 0xff;
+	buffer[1] = 0x80;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	ASSERT.equal(Number.NEGATIVE_INFINITY,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+	buffer[3] = 0xff;
+	buffer[2] = 0x80;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(Number.NEGATIVE_INFINITY,
+	    mod_ctype.rfloat(buffer, 'litle', 0));
+
+	/* Catch NaN */
+
+	buffer[0] = 0x7f;
+	buffer[1] = 0x80;
+	buffer[2] = 0x00;
+	buffer[3] = 0x23;
+	ASSERT.ok(isNaN(mod_ctype.rfloat(buffer, 'big', 0)));
+	buffer[3] = 0x7f;
+	buffer[2] = 0x80;
+	buffer[1] = 0x00;
+	buffer[0] = 0x23;
+	ASSERT.ok(isNaN(mod_ctype.rfloat(buffer, 'little', 0)));
+
+	/* Catch -infin */
+	buffer[0] = 0xff;
+	buffer[1] = 0x80;
+	buffer[2] = 0x00;
+	buffer[3] = 0x23;
+	ASSERT.ok(isNaN(mod_ctype.rfloat(buffer, 'big', 0)));
+	buffer[3] = 0xff;
+	buffer[2] = 0x80;
+	buffer[1] = 0x00;
+	buffer[0] = 0x23;
+	ASSERT.ok(isNaN(mod_ctype.rfloat(buffer, 'little', 0)));
+
+	/* On to some basic tests */
+	/* 1.125 */
+	buffer[0] = 0x3f;
+	buffer[1] = 0x90;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	ASSERT.equal(1.125, mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x3f;
+	buffer[2] = 0x90;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(1.125, mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* ff34a2b0 -2.4010576103645774e+38 */
+	buffer[0] = 0xff;
+	buffer[1] = 0x34;
+	buffer[2] = 0xa2;
+	buffer[3] = 0xb0;
+	ASSERT.equal(-2.4010576103645774e+38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0xff;
+	buffer[2] = 0x34;
+	buffer[1] = 0xa2;
+	buffer[0] = 0xb0;
+	ASSERT.equal(-2.4010576103645774e+38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* Denormalized tests */
+
+	/* 0003f89a +/- 3.6468792534053364e-40 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x03;
+	buffer[2] = 0xf8;
+	buffer[3] = 0x9a;
+	ASSERT.equal(3.6468792534053364e-40,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x00;
+	buffer[2] = 0x03;
+	buffer[1] = 0xf8;
+	buffer[0] = 0x9a;
+	ASSERT.equal(3.6468792534053364e-40,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x03;
+	buffer[2] = 0xf8;
+	buffer[3] = 0x9a;
+	ASSERT.equal(-3.6468792534053364e-40,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x80;
+	buffer[2] = 0x03;
+	buffer[1] = 0xf8;
+	buffer[0] = 0x9a;
+	ASSERT.equal(-3.6468792534053364e-40,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+
+	/* Maximum and minimum normalized and denormalized values */
+
+	/* Largest normalized number +/- 3.4028234663852886e+38 */
+
+	buffer[0] = 0x7f;
+	buffer[1] = 0x7f;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	ASSERT.equal(3.4028234663852886e+38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x7f;
+	buffer[2] = 0x7f;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(3.4028234663852886e+38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	buffer[0] = 0xff;
+	buffer[1] = 0x7f;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	ASSERT.equal(-3.4028234663852886e+38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0xff;
+	buffer[2] = 0x7f;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(-3.4028234663852886e+38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* Smallest normalied number +/- 1.1754943508222875e-38 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x80;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	ASSERT.equal(1.1754943508222875e-38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x00;
+	buffer[2] = 0x80;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(1.1754943508222875e-38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x80;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	ASSERT.equal(-1.1754943508222875e-38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x80;
+	buffer[2] = 0x80;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(-1.1754943508222875e-38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+
+	/* Smallest denormalized number 1.401298464324817e-45 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x00;
+	buffer[2] = 0x00;
+	buffer[3] = 0x01;
+	ASSERT.equal(1.401298464324817e-45,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x00;
+	buffer[2] = 0x00;
+	buffer[1] = 0x00;
+	buffer[0] = 0x01;
+	ASSERT.equal(1.401298464324817e-45,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x00;
+	buffer[2] = 0x00;
+	buffer[3] = 0x01;
+	ASSERT.equal(-1.401298464324817e-45,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x80;
+	buffer[2] = 0x00;
+	buffer[1] = 0x00;
+	buffer[0] = 0x01;
+	ASSERT.equal(-1.401298464324817e-45,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* Largest denormalized value +/- 1.1754942106924411e-38 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x7f;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	ASSERT.equal(1.1754942106924411e-38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x00;
+	buffer[2] = 0x7f;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(1.1754942106924411e-38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x7f;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	ASSERT.equal(-1.1754942106924411e-38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+
+	buffer[3] = 0x80;
+	buffer[2] = 0x7f;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(-1.1754942106924411e-38,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+
+	/* Do some quick offset testing */
+	buffer = new Buffer(6);
+	buffer[0] = 0x7f;
+	buffer[1] = 0x4e;
+	buffer[2] = 0x8a;
+	buffer[3] = 0x79;
+	buffer[4] = 0xcd;
+	buffer[5] = 0x3f;
+
+	ASSERT.equal(2.745399582697325e+38,
+	    mod_ctype.rfloat(buffer, 'big', 0));
+	ASSERT.equal(1161619072,
+	    mod_ctype.rfloat(buffer, 'big', 1));
+	ASSERT.equal(-1.2027516403607578e-32,
+	    mod_ctype.rfloat(buffer, 'big', 2));
+
+	ASSERT.equal(8.97661320504413e+34,
+	    mod_ctype.rfloat(buffer, 'little', 0));
+	ASSERT.equal(-261661920,
+	    mod_ctype.rfloat(buffer, 'little', 1));
+	ASSERT.equal(1.605271577835083,
+	    mod_ctype.rfloat(buffer, 'little', 2));
+
+}
+
+function testdouble()
+{
+	var buffer = new Buffer(10);
+
+	/* Check 0 */
+	buffer[0] = 0;
+	buffer[1] = 0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 0;
+	ASSERT.equal(0,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+	ASSERT.equal(0,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 0;
+	ASSERT.equal(0,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+	buffer[7] = 0x80;
+	buffer[6] = 0;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 0;
+	ASSERT.equal(0,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Check NaN */
+	buffer[0] = 0x7f;
+	buffer[1] = 0xf0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 23;
+	ASSERT.ok(isNaN(mod_ctype.rdouble(buffer, 'big', 0)));
+
+	buffer[7] = 0x7f;
+	buffer[6] = 0xf0;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 23;
+	ASSERT.ok(isNaN(mod_ctype.rdouble(buffer, 'little', 0)));
+
+	buffer[0] = 0xff;
+	buffer[1] = 0xf0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 23;
+	ASSERT.ok(isNaN(mod_ctype.rdouble(buffer, 'big', 0)));
+
+	buffer[7] = 0xff;
+	buffer[6] = 0xf0;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 23;
+	ASSERT.ok(isNaN(mod_ctype.rdouble(buffer, 'little', 0)));
+
+	/* pos inf */
+	buffer[0] = 0x7f;
+	buffer[1] = 0xf0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 0;
+	ASSERT.equal(Number.POSITIVE_INFINITY,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x7f;
+	buffer[6] = 0xf0;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 0;
+	ASSERT.equal(Number.POSITIVE_INFINITY,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* neg inf */
+	buffer[0] = 0xff;
+	buffer[1] = 0xf0;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 0;
+	ASSERT.equal(Number.NEGATIVE_INFINITY,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0xff;
+	buffer[6] = 0xf0;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 0;
+	ASSERT.equal(Number.NEGATIVE_INFINITY,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Simple normalized values */
+
+	/* +/- 1.125 */
+	buffer[0] = 0x3f;
+	buffer[1] = 0xf2;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 0;
+	ASSERT.equal(1.125,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x3f;
+	buffer[6] = 0xf2;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 0;
+	ASSERT.equal(1.125,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0xbf;
+	buffer[1] = 0xf2;
+	buffer[2] = 0;
+	buffer[3] = 0;
+	buffer[4] = 0;
+	buffer[5] = 0;
+	buffer[6] = 0;
+	buffer[7] = 0;
+	ASSERT.equal(-1.125,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0xbf;
+	buffer[6] = 0xf2;
+	buffer[5] = 0;
+	buffer[4] = 0;
+	buffer[3] = 0;
+	buffer[2] = 0;
+	buffer[1] = 0;
+	buffer[0] = 0;
+	ASSERT.equal(-1.125,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* +/- 1.4397318913736026e+283 */
+	buffer[0] = 0x7a;
+	buffer[1] = 0xb8;
+	buffer[2] = 0xc9;
+	buffer[3] = 0x34;
+	buffer[4] = 0x72;
+	buffer[5] = 0x16;
+	buffer[6] = 0xf9;
+	buffer[7] = 0x0e;
+	ASSERT.equal(1.4397318913736026e+283,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x7a;
+	buffer[6] = 0xb8;
+	buffer[5] = 0xc9;
+	buffer[4] = 0x34;
+	buffer[3] = 0x72;
+	buffer[2] = 0x16;
+	buffer[1] = 0xf9;
+	buffer[0] = 0x0e;
+	ASSERT.equal(1.4397318913736026e+283,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0xfa;
+	buffer[1] = 0xb8;
+	buffer[2] = 0xc9;
+	buffer[3] = 0x34;
+	buffer[4] = 0x72;
+	buffer[5] = 0x16;
+	buffer[6] = 0xf9;
+	buffer[7] = 0x0e;
+	ASSERT.equal(-1.4397318913736026e+283,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0xfa;
+	buffer[6] = 0xb8;
+	buffer[5] = 0xc9;
+	buffer[4] = 0x34;
+	buffer[3] = 0x72;
+	buffer[2] = 0x16;
+	buffer[1] = 0xf9;
+	buffer[0] = 0x0e;
+	ASSERT.equal(-1.4397318913736026e+283,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Denormalized values */
+	/* +/- 8.82521232268344e-309 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x06;
+	buffer[2] = 0x58;
+	buffer[3] = 0x94;
+	buffer[4] = 0x13;
+	buffer[5] = 0x27;
+	buffer[6] = 0x8a;
+	buffer[7] = 0xcd;
+	ASSERT.equal(8.82521232268344e-309,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x00;
+	buffer[6] = 0x06;
+	buffer[5] = 0x58;
+	buffer[4] = 0x94;
+	buffer[3] = 0x13;
+	buffer[2] = 0x27;
+	buffer[1] = 0x8a;
+	buffer[0] = 0xcd;
+	ASSERT.equal(8.82521232268344e-309,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x06;
+	buffer[2] = 0x58;
+	buffer[3] = 0x94;
+	buffer[4] = 0x13;
+	buffer[5] = 0x27;
+	buffer[6] = 0x8a;
+	buffer[7] = 0xcd;
+	ASSERT.equal(-8.82521232268344e-309,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x80;
+	buffer[6] = 0x06;
+	buffer[5] = 0x58;
+	buffer[4] = 0x94;
+	buffer[3] = 0x13;
+	buffer[2] = 0x27;
+	buffer[1] = 0x8a;
+	buffer[0] = 0xcd;
+	ASSERT.equal(-8.82521232268344e-309,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Edge cases, maximum and minimum values */
+
+	/* Smallest denormalized value 5e-324 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x00;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	buffer[4] = 0x00;
+	buffer[5] = 0x00;
+	buffer[6] = 0x00;
+	buffer[7] = 0x01;
+	ASSERT.equal(5e-324,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x00;
+	buffer[6] = 0x00;
+	buffer[5] = 0x00;
+	buffer[4] = 0x00;
+	buffer[3] = 0x00;
+	buffer[2] = 0x00;
+	buffer[1] = 0x00;
+	buffer[0] = 0x01;
+	ASSERT.equal(5e-324,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x00;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	buffer[4] = 0x00;
+	buffer[5] = 0x00;
+	buffer[6] = 0x00;
+	buffer[7] = 0x01;
+	ASSERT.equal(-5e-324,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x80;
+	buffer[6] = 0x00;
+	buffer[5] = 0x00;
+	buffer[4] = 0x00;
+	buffer[3] = 0x00;
+	buffer[2] = 0x00;
+	buffer[1] = 0x00;
+	buffer[0] = 0x01;
+	ASSERT.equal(-5e-324,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Largest denormalized value 2.225073858507201e-308 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x0f;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	buffer[4] = 0xff;
+	buffer[5] = 0xff;
+	buffer[6] = 0xff;
+	buffer[7] = 0xff;
+	ASSERT.equal(2.225073858507201e-308,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x00;
+	buffer[6] = 0x0f;
+	buffer[5] = 0xff;
+	buffer[4] = 0xff;
+	buffer[3] = 0xff;
+	buffer[2] = 0xff;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(2.225073858507201e-308,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x0f;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	buffer[4] = 0xff;
+	buffer[5] = 0xff;
+	buffer[6] = 0xff;
+	buffer[7] = 0xff;
+	ASSERT.equal(-2.225073858507201e-308,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x80;
+	buffer[6] = 0x0f;
+	buffer[5] = 0xff;
+	buffer[4] = 0xff;
+	buffer[3] = 0xff;
+	buffer[2] = 0xff;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(-2.225073858507201e-308,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Smallest normalized value 2.2250738585072014e-308 */
+	buffer[0] = 0x00;
+	buffer[1] = 0x10;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	buffer[4] = 0x00;
+	buffer[5] = 0x00;
+	buffer[6] = 0x00;
+	buffer[7] = 0x00;
+	ASSERT.equal(2.2250738585072014e-308,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x00;
+	buffer[6] = 0x10;
+	buffer[5] = 0x00;
+	buffer[4] = 0x00;
+	buffer[3] = 0x00;
+	buffer[2] = 0x00;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(2.2250738585072014e-308,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0x80;
+	buffer[1] = 0x10;
+	buffer[2] = 0x00;
+	buffer[3] = 0x00;
+	buffer[4] = 0x00;
+	buffer[5] = 0x00;
+	buffer[6] = 0x00;
+	buffer[7] = 0x00;
+	ASSERT.equal(-2.2250738585072014e-308,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x80;
+	buffer[6] = 0x10;
+	buffer[5] = 0x00;
+	buffer[4] = 0x00;
+	buffer[3] = 0x00;
+	buffer[2] = 0x00;
+	buffer[1] = 0x00;
+	buffer[0] = 0x00;
+	ASSERT.equal(-2.2250738585072014e-308,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Largest normalized value 1.7976931348623157e+308 */
+	buffer[0] = 0x7f;
+	buffer[1] = 0xef;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	buffer[4] = 0xff;
+	buffer[5] = 0xff;
+	buffer[6] = 0xff;
+	buffer[7] = 0xff;
+	ASSERT.equal(1.7976931348623157e+308,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0x7f;
+	buffer[6] = 0xef;
+	buffer[5] = 0xff;
+	buffer[4] = 0xff;
+	buffer[3] = 0xff;
+	buffer[2] = 0xff;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(1.7976931348623157e+308,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	buffer[0] = 0xff;
+	buffer[1] = 0xef;
+	buffer[2] = 0xff;
+	buffer[3] = 0xff;
+	buffer[4] = 0xff;
+	buffer[5] = 0xff;
+	buffer[6] = 0xff;
+	buffer[7] = 0xff;
+	ASSERT.equal(-1.7976931348623157e+308,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+
+	buffer[7] = 0xff;
+	buffer[6] = 0xef;
+	buffer[5] = 0xff;
+	buffer[4] = 0xff;
+	buffer[3] = 0xff;
+	buffer[2] = 0xff;
+	buffer[1] = 0xff;
+	buffer[0] = 0xff;
+	ASSERT.equal(-1.7976931348623157e+308,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+
+	/* Try offsets */
+	buffer[0] = 0xde;
+	buffer[1] = 0xad;
+	buffer[2] = 0xbe;
+	buffer[3] = 0xef;
+	buffer[4] = 0xba;
+	buffer[5] = 0xdd;
+	buffer[6] = 0xca;
+	buffer[7] = 0xfe;
+	buffer[8] = 0x16;
+	buffer[9] = 0x79;
+
+	ASSERT.equal(-1.1885958404126936e+148,
+	    mod_ctype.rdouble(buffer, 'big', 0));
+	ASSERT.equal(-2.4299184080448593e-88,
+	    mod_ctype.rdouble(buffer, 'big', 1));
+	ASSERT.equal(-0.000015130017658081283,
+	    mod_ctype.rdouble(buffer, 'big', 2));
+
+	ASSERT.equal(-5.757458694845505e+302,
+	    mod_ctype.rdouble(buffer, 'little', 0));
+	ASSERT.equal(6.436459604192476e-198,
+	    mod_ctype.rdouble(buffer, 'little', 1));
+	ASSERT.equal(1.9903745632417286e+275,
+	    mod_ctype.rdouble(buffer, 'little', 2));
+}
+
+testfloat();
+testdouble();