You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
207 lines
7.0 KiB
207 lines
7.0 KiB
'use strict'; |
|
|
|
require('./polyfill'); |
|
|
|
// A simple abbreviation to obtain a buffer from a hex string |
|
function h2b(str) { |
|
return new Buffer(str, "hex"); |
|
} |
|
|
|
// Reverse a buffer |
|
function reverse(buf) { |
|
var res = new Buffer(buf.length); |
|
for (var i = 0, j = buf.length - 1; j >= 0; i++, j--) { |
|
res[i] = buf[j]; |
|
} |
|
return res; |
|
} |
|
|
|
// Fill a buffer with distinctive data |
|
function scrub(buf) { |
|
var pos = 0; |
|
var written; |
|
while ((written = buf.write("deadbeef", pos, 4, "hex")) == 4) { |
|
pos += written; |
|
} |
|
return buf; |
|
} |
|
|
|
function xint_case(xint) { |
|
return function (assert, hex, val, inexact) { |
|
var readBE = "read" + xint + "BE"; |
|
var writeBE = "write" + xint + "BE"; |
|
var readLE = "read" + xint + "LE"; |
|
var writeLE = "write" + xint + "LE"; |
|
|
|
var len = hex.length / 2; |
|
|
|
// Straightforward read cases |
|
assert.equal(h2b(hex)[readBE](len, 0), val); |
|
assert.equal(reverse(h2b(hex))[readLE](len, 0), val); |
|
|
|
// Test straightforward writes and noAssert writes off the ends of |
|
// the buffer |
|
var buf = scrub(new Buffer(len)); |
|
buf[writeBE](len, val, 0); |
|
if (!inexact) { |
|
assert.equal(buf.toString("hex"), hex); |
|
} else { |
|
assert.equal(buf[readBE](len, 0), val); |
|
} |
|
|
|
var buf2 = scrub(new Buffer(len)); |
|
buf2[writeBE](len, val, -1, true); |
|
assert.equal(buf2.slice(0, len-1).toString("hex"), |
|
buf.slice(1, len).toString("hex")); |
|
scrub(buf2); |
|
buf2[writeBE](len, val, 1, true); |
|
assert.equal(buf2.slice(1, len).toString("hex"), |
|
buf.slice(0, len-1).toString("hex")); |
|
|
|
scrub(buf); |
|
buf[writeLE](len, val, 0); |
|
if (!inexact) { |
|
assert.equal(reverse(buf).toString("hex"), hex); |
|
} else { |
|
assert.equal(buf[readLE](len, 0), val); |
|
} |
|
|
|
scrub(buf2); |
|
buf2[writeLE](len, val, -1, true); |
|
assert.equal(buf2.slice(0, len-1).toString("hex"), |
|
buf.slice(1, len).toString("hex")); |
|
scrub(buf2); |
|
buf2[writeLE](len, val, 1, true); |
|
assert.equal(buf2.slice(1, len).toString("hex"), |
|
buf.slice(0, len-1).toString("hex")); |
|
|
|
// Accessess off the end of the buffer should throw. Node |
|
// doesn't catch negative offsets. |
|
assert.throws(function () { h2b(hex)[readBE](len, 1); }) |
|
assert.throws(function () { reverse(h2b(hex))[readLE](len, 1); }) |
|
assert.throws(function () { buf[writeBE](len, val, 1); }); |
|
assert.throws(function () { buf[writeLE](len, val, 1); }); |
|
|
|
// Test noAssert reads that stray off the ends of the buffer. |
|
var expect = h2b("00"+hex)[readBE](len, 0); |
|
assert.equal(h2b(hex)[readBE](len, -1, true), expect); |
|
assert.equals(reverse(h2b(hex))[readLE](len, 1, true), expect); |
|
|
|
expect = h2b(hex+"00")[readBE](len, 1); |
|
assert.equal(h2b(hex)[readBE](len, 1, true), expect); |
|
assert.equal(reverse(h2b(hex))[readLE](len, -1, true), expect); |
|
}; |
|
} |
|
|
|
var uint_case = xint_case("UInt"); |
|
var int_case = xint_case("Int"); |
|
|
|
module.exports.uint = function (assert) { |
|
uint_case(assert, "00", 0x00); |
|
uint_case(assert, "01", 0x01); |
|
uint_case(assert, "ff", 0xff); |
|
|
|
uint_case(assert, "0000", 0x0000); |
|
uint_case(assert, "0102", 0x0102); |
|
uint_case(assert, "ffff", 0xffff); |
|
|
|
uint_case(assert, "000000", 0x000000); |
|
uint_case(assert, "010203", 0x010203); |
|
uint_case(assert, "ffffff", 0xffffff); |
|
|
|
uint_case(assert, "00000000", 0x00000000); |
|
uint_case(assert, "01020304", 0x01020304); |
|
uint_case(assert, "ffffffff", 0xffffffff); |
|
|
|
uint_case(assert, "0000000000", 0x0000000000); |
|
uint_case(assert, "0102030405", 0x0102030405); |
|
uint_case(assert, "ffffffffff", 0xffffffffff); |
|
|
|
uint_case(assert, "000000000000", 0x000000000000); |
|
uint_case(assert, "010203040506", 0x010203040506); |
|
uint_case(assert, "ffffffffffff", 0xffffffffffff); |
|
|
|
uint_case(assert, "00000000000000", 0x00000000000000); |
|
uint_case(assert, "01020304050607", 0x01020304050607); |
|
uint_case(assert, "ffffffffffffff", 0xffffffffffffff); |
|
|
|
uint_case(assert, "0000000000000000", 0x0000000000000000); |
|
uint_case(assert, "0102030405060708", 0x0102030405060708, true); |
|
uint_case(assert, "ffffffffffffffff", 0xffffffffffffffff); |
|
|
|
assert.done(); |
|
}; |
|
|
|
module.exports.int = function (assert) { |
|
int_case(assert, "00", 0x00); |
|
int_case(assert, "01", 0x01); |
|
int_case(assert, "7f", 0x7f); |
|
int_case(assert, "80", -0x80); |
|
int_case(assert, "ff", -0x01); |
|
|
|
int_case(assert, "0000", 0x0000); |
|
int_case(assert, "0102", 0x0102); |
|
int_case(assert, "7fff", 0x7fff); |
|
int_case(assert, "8000", -0x8000); |
|
int_case(assert, "ffff", -0x0001); |
|
|
|
int_case(assert, "000000", 0x000000); |
|
int_case(assert, "010203", 0x010203); |
|
int_case(assert, "7fffff", 0x7fffff); |
|
int_case(assert, "800000", -0x800000); |
|
int_case(assert, "ffffff", -0x000001); |
|
|
|
int_case(assert, "00000000", 0x00000000); |
|
int_case(assert, "01020304", 0x01020304); |
|
int_case(assert, "7fffffff", 0x7fffffff); |
|
int_case(assert, "80000000", -0x80000000); |
|
int_case(assert, "ffffffff", -0x00000001); |
|
|
|
int_case(assert, "0000000000", 0x0000000000); |
|
int_case(assert, "0102030405", 0x0102030405); |
|
int_case(assert, "7fffffffff", 0x7fffffffff); |
|
int_case(assert, "8000000000", -0x8000000000); |
|
int_case(assert, "ffffffffff", -0x0000000001); |
|
|
|
int_case(assert, "000000000000", 0x000000000000); |
|
int_case(assert, "010203040506", 0x010203040506); |
|
int_case(assert, "7fffffffffff", 0x7fffffffffff); |
|
int_case(assert, "800000000000", -0x800000000000); |
|
int_case(assert, "ffffffffffff", -0x000000000001); |
|
|
|
int_case(assert, "00000000000000", 0x00000000000000); |
|
int_case(assert, "01020304050607", 0x01020304050607); |
|
int_case(assert, "7fffffffffffff", 0x7fffffffffffff); |
|
int_case(assert, "80000000000000", -0x80000000000000); |
|
int_case(assert, "ffffffffffffff", -0x00000000000001); |
|
|
|
int_case(assert, "0000000000000000", 0x0000000000000000); |
|
int_case(assert, "0102030405060708", 0x0102030405060708, true); |
|
int_case(assert, "7fffffffffffffff", 0x7fffffffffffffff); |
|
int_case(assert, "8000000000000000", -0x8000000000000000); |
|
int_case(assert, "ffffffffffffffff", -0x0000000000000001); |
|
|
|
assert.done(); |
|
}; |
|
|
|
module.exports.isContiguousInt = function (assert) { |
|
assert.equal(Buffer.isContiguousInt(0x1fffffffffffff), true); |
|
assert.equal(Buffer.isContiguousInt(0x20000000000000), false); |
|
assert.equal(Buffer.isContiguousInt(-0x1fffffffffffff), true); |
|
assert.equal(Buffer.isContiguousInt(-0x20000000000000), false); |
|
|
|
assert.doesNotThrow(function () { |
|
Buffer.assertContiguousInt(0x1fffffffffffff); |
|
}); |
|
assert.throws(function () { |
|
Buffer.assertContiguousInt(0x20000000000000); |
|
}); |
|
assert.doesNotThrow(function () { |
|
Buffer.assertContiguousInt(-0x1fffffffffffff); |
|
}); |
|
assert.throws(function () { |
|
Buffer.assertContiguousInt(-0x20000000000000); |
|
}); |
|
|
|
assert.done(); |
|
};
|
|
|