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.
208 lines
7.0 KiB
208 lines
7.0 KiB
5 years ago
|
'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();
|
||
|
};
|