Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Node 12 support and dependency/version updates #25

Merged
merged 2 commits into from
Oct 25, 2019
Merged

Node 12 support and dependency/version updates #25

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
ac22d6e
Node 12 support
abalabahaha Aug 5, 2019
b71fe48
Updated NPM version and dependencies
TheAkio Oct 25, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
100 changes: 50 additions & 50 deletions js/__tests__/decoder-test.js
View file
Open in desktop
Expand Up @@ -10,23 +10,23 @@ const helloWorldBinaryWithNull = '\x01\x02\x03\x04\x05\x00\x06\x07\x08\x09\x0A\x

describe('unpacks', () => {
it('short list via string with null byte', () => {
expect(erlpack.unpack(new Buffer('\x83k\x00\x0c' + helloWorldBinaryWithNull, 'binary'))).toEqual(helloWorldListWithNull);
expect(erlpack.unpack(Buffer.from('\x83k\x00\x0c' + helloWorldBinaryWithNull, 'binary'))).toEqual(helloWorldListWithNull);
});

it('short list via string without byte', () => {
expect(erlpack.unpack(new Buffer('\x83k\x00\x0b' + helloWorldBinary, 'binary'))).toEqual(helloWorldList);
expect(erlpack.unpack(Buffer.from('\x83k\x00\x0b' + helloWorldBinary, 'binary'))).toEqual(helloWorldList);
});

it('binary with null byte', () => {
expect(erlpack.unpack(new Buffer('\x83m\x00\x00\x00\x0chello\x00 world', 'binary'))).toEqual('hello\x00 world');
expect(erlpack.unpack(Buffer.from('\x83m\x00\x00\x00\x0chello\x00 world', 'binary'))).toEqual('hello\x00 world');
});

it('binary without null byte', () => {
expect(erlpack.unpack(new Buffer('\x83m\x00\x00\x00\x0bhello world', 'binary'))).toEqual('hello world');
expect(erlpack.unpack(Buffer.from('\x83m\x00\x00\x00\x0bhello world', 'binary'))).toEqual('hello world');
});

it('dictionary', () => {
const data = new Buffer(
const data = Buffer.from(
'\x83t\x00\x00\x00\x03a\x02a\x02a\x03l\x00\x00\x00\x03a\x01a\x02a\x03jm\x00\x00\x00\x01aa\x01',
'binary'
);
Expand All @@ -35,38 +35,38 @@ describe('unpacks', () => {
});

it('false', () => {
expect(erlpack.unpack(new Buffer('\x83s\x05false', 'binary'))).toEqual(false);
expect(erlpack.unpack(Buffer.from('\x83s\x05false', 'binary'))).toEqual(false);
});

it('true', () => {
expect(erlpack.unpack(new Buffer('\x83s\x04true', 'binary'))).toEqual(true);
expect(erlpack.unpack(Buffer.from('\x83s\x04true', 'binary'))).toEqual(true);
});

it('nil token is array', () => {
expect(erlpack.unpack(new Buffer('\x83j', 'binary'))).toEqual([]);
expect(erlpack.unpack(Buffer.from('\x83j', 'binary'))).toEqual([]);
});

it('nil atom is null', () => {
expect(erlpack.unpack(new Buffer('\x83s\x03nil', 'binary'))).toBeNull();
expect(erlpack.unpack(Buffer.from('\x83s\x03nil', 'binary'))).toBeNull();
});

it('null is null', () => {
expect(erlpack.unpack(new Buffer('\x83s\x04null', 'binary'))).toBeNull();
expect(erlpack.unpack(Buffer.from('\x83s\x04null', 'binary'))).toBeNull();
});

it('floats', () => {
expect(erlpack.unpack(new Buffer('\x83c2.50000000000000000000e+00\x00\x00\x00\x00\x00', 'binary'))).toEqual(2.5);
expect(erlpack.unpack(new Buffer('\x83c5.15121238412343125000e+13\x00\x00\x00\x00\x00', 'binary'))).toEqual(51512123841234.31423412341435123412341342);
expect(erlpack.unpack(Buffer.from('\x83c2.50000000000000000000e+00\x00\x00\x00\x00\x00', 'binary'))).toEqual(2.5);
expect(erlpack.unpack(Buffer.from('\x83c5.15121238412343125000e+13\x00\x00\x00\x00\x00', 'binary'))).toEqual(51512123841234.31423412341435123412341342);
});

it('new floats', () => {
expect(erlpack.unpack(new Buffer('\x83F\x40\x04\x00\x00\x00\x00\x00\x00', 'binary'))).toEqual(2.5);
expect(erlpack.unpack(new Buffer('\x83F\x42\xC7\x6C\xCC\xEB\xED\x69\x28', 'binary'))).toEqual(51512123841234.31423412341435123412341342);
expect(erlpack.unpack(Buffer.from('\x83F\x40\x04\x00\x00\x00\x00\x00\x00', 'binary'))).toEqual(2.5);
expect(erlpack.unpack(Buffer.from('\x83F\x42\xC7\x6C\xCC\xEB\xED\x69\x28', 'binary'))).toEqual(51512123841234.31423412341435123412341342);
});

it('small int', () => {
function check(small_int) {
const expected = new Buffer(3);
const expected = Buffer.alloc(3);
expected.write('\x83a', 0, 2, 'binary');
expected.writeUInt8(small_int, 2);
expect(erlpack.unpack(expected)).toEqual(small_int);
Expand All @@ -78,46 +78,46 @@ describe('unpacks', () => {
});

it('int32', () => {
expect(erlpack.unpack(new Buffer('\x83b\x00\x00\x04\x00', 'binary'))).toEqual(1024);
expect(erlpack.unpack(new Buffer('\x83b\x80\x00\x00\x00', 'binary'))).toEqual(-2147483648);
expect(erlpack.unpack(new Buffer('\x83b\x7f\xff\xff\xff', 'binary'))).toEqual(2147483647);
expect(erlpack.unpack(Buffer.from('\x83b\x00\x00\x04\x00', 'binary'))).toEqual(1024);
expect(erlpack.unpack(Buffer.from('\x83b\x80\x00\x00\x00', 'binary'))).toEqual(-2147483648);
expect(erlpack.unpack(Buffer.from('\x83b\x7f\xff\xff\xff', 'binary'))).toEqual(2147483647);
});

it('small big ints', () => {
expect(erlpack.unpack(new Buffer('\x83n\x04\x01\x01\x02\x03\x04', 'binary'))).toEqual(-67305985);
expect(erlpack.unpack(new Buffer('\x83n\x04\x00\x01\x02\x03\x04', 'binary'))).toEqual(67305985);
expect(erlpack.unpack(new Buffer('\x83n\x08\x01\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("-578437695752307201");
expect(erlpack.unpack(new Buffer('\x83n\x08\x00\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("578437695752307201");
expect(() => erlpack.unpack(new Buffer('\x83n\x0A\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A', 'binary'))).toThrow("Unable to decode big ints larger than 8 bytes");
expect(erlpack.unpack(Buffer.from('\x83n\x04\x01\x01\x02\x03\x04', 'binary'))).toEqual(-67305985);
expect(erlpack.unpack(Buffer.from('\x83n\x04\x00\x01\x02\x03\x04', 'binary'))).toEqual(67305985);
expect(erlpack.unpack(Buffer.from('\x83n\x08\x01\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("-578437695752307201");
expect(erlpack.unpack(Buffer.from('\x83n\x08\x00\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("578437695752307201");
expect(() => erlpack.unpack(Buffer.from('\x83n\x0A\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A', 'binary'))).toThrow("Unable to decode big ints larger than 8 bytes");
});

it('large big ints', () => {
expect(erlpack.unpack(new Buffer('\x83o\x00\x00\x00\x04\x01\x01\x02\x03\x04', 'binary'))).toEqual(-67305985);
expect(erlpack.unpack(new Buffer('\x83o\x00\x00\x00\x04\x00\x01\x02\x03\x04', 'binary'))).toEqual(67305985);
expect(erlpack.unpack(new Buffer('\x83o\x00\x00\x00\x08\x01\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("-578437695752307201");
expect(erlpack.unpack(new Buffer('\x83o\x00\x00\x00\x08\x00\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("578437695752307201");
expect(() => erlpack.unpack(new Buffer('\x83o\x00\x00\x00\x0A\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A', 'binary'))).toThrow("Unable to decode big ints larger than 8 bytes");
expect(erlpack.unpack(Buffer.from('\x83o\x00\x00\x00\x04\x01\x01\x02\x03\x04', 'binary'))).toEqual(-67305985);
expect(erlpack.unpack(Buffer.from('\x83o\x00\x00\x00\x04\x00\x01\x02\x03\x04', 'binary'))).toEqual(67305985);
expect(erlpack.unpack(Buffer.from('\x83o\x00\x00\x00\x08\x01\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("-578437695752307201");
expect(erlpack.unpack(Buffer.from('\x83o\x00\x00\x00\x08\x00\x01\x02\x03\x04\x05\x06\x07\x08', 'binary'))).toEqual("578437695752307201");
expect(() => erlpack.unpack(Buffer.from('\x83o\x00\x00\x00\x0A\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A', 'binary'))).toThrow("Unable to decode big ints larger than 8 bytes");
});

it('atoms', () => {
expect(erlpack.unpack(new Buffer('\x83d\x00\x0Dguild members', 'binary'))).toEqual("guild members");
expect(erlpack.unpack(Buffer.from('\x83d\x00\x0Dguild members', 'binary'))).toEqual("guild members");
});

it('tuples', () => {
expect(erlpack.unpack(new Buffer('\x83h\x03m\x00\x00\x00\x06vanisha\x01a\x04', 'binary'))).toEqual(['vanish', 1, 4]);
expect(erlpack.unpack(new Buffer('\x83i\x00\x00\x00\x03m\x00\x00\x00\x06vanisha\x01a\x04', 'binary'))).toEqual(['vanish', 1, 4]);
expect(erlpack.unpack(Buffer.from('\x83h\x03m\x00\x00\x00\x06vanisha\x01a\x04', 'binary'))).toEqual(['vanish', 1, 4]);
expect(erlpack.unpack(Buffer.from('\x83i\x00\x00\x00\x03m\x00\x00\x00\x06vanisha\x01a\x04', 'binary'))).toEqual(['vanish', 1, 4]);
});

it('compressed', () => {
const expected = [2, Array.from("it's getting hot in here.").map(x => x.charCodeAt(0))];
expect(erlpack.unpack(new Buffer('\x83l\x00\x00\x00\x02a\x02k\x00\x19it\'s getting hot in here.j', 'binary'))).toEqual(expected);
expect(erlpack.unpack(new Buffer('\x83P\x00\x00\x00\x24\x78\x9C\xCB\x61\x60\x60\x60\x4A\x64\xCA\x66\x90\xCC\x2C\x51\x2F\x56\x48\x4F\x2D\x29\xC9\xCC\x4B\x57\xC8\xC8\x2F\x51\xC8\xCC\x53\xC8\x48\x2D\x4A\xD5\xCB\x02\x00\xA8\xA8\x0A\x9D', 'binary'))).toEqual(expected);
expect(erlpack.unpack(Buffer.from('\x83l\x00\x00\x00\x02a\x02k\x00\x19it\'s getting hot in here.j', 'binary'))).toEqual(expected);
expect(erlpack.unpack(Buffer.from('\x83P\x00\x00\x00\x24\x78\x9C\xCB\x61\x60\x60\x60\x4A\x64\xCA\x66\x90\xCC\x2C\x51\x2F\x56\x48\x4F\x2D\x29\xC9\xCC\x4B\x57\xC8\xC8\x2F\x51\xC8\xCC\x53\xC8\x48\x2D\x4A\xD5\xCB\x02\x00\xA8\xA8\x0A\x9D', 'binary'))).toEqual(expected);
});

it('nested compressed', () => {
const expected = [[2, Array.from("it's getting hot in here.").map(x => x.charCodeAt(0))], 3];
expect(erlpack.unpack(new Buffer('\x83l\x00\x00\x00\x02l\x00\x00\x00\x02a\x02k\x00\x19it\'s getting hot in here.ja\x03j', 'binary'))).toEqual(expected);
expect(erlpack.unpack(new Buffer('\x83P\x00\x00\x00\x2C\x78\x9C\xCB\x61\x60\x60\x60\xCA\x01\x11\x89\x4C\xD9\x0C\x92\x99\x25\xEA\xC5\x0A\xE9\xA9\x25\x25\x99\x79\xE9\x0A\x19\xF9\x25\x0A\x99\x79\x0A\x19\xA9\x45\xA9\x7A\x59\x89\xCC\x59\x00\xDC\xF7\x0B\xD9', 'binary'))).toEqual(expected);
expect(erlpack.unpack(Buffer.from('\x83l\x00\x00\x00\x02l\x00\x00\x00\x02a\x02k\x00\x19it\'s getting hot in here.ja\x03j', 'binary'))).toEqual(expected);
expect(erlpack.unpack(Buffer.from('\x83P\x00\x00\x00\x2C\x78\x9C\xCB\x61\x60\x60\x60\xCA\x01\x11\x89\x4C\xD9\x0C\x92\x99\x25\xEA\xC5\x0A\xE9\xA9\x25\x25\x99\x79\xE9\x0A\x19\xF9\x25\x0A\x99\x79\x0A\x19\xA9\x45\xA9\x7A\x59\x89\xCC\x59\x00\xDC\xF7\x0B\xD9', 'binary'))).toEqual(expected);
});

it('references', () => {
Expand All @@ -126,14 +126,14 @@ describe('unpacks', () => {
"id": [1245],
"creation": 1
};
expect(erlpack.unpack(new Buffer('\x83em\x00\x00\x00\x05Hello\x00\x00\x04\xDD\x01', 'binary'))).toEqual(reference);
expect(erlpack.unpack(Buffer.from('\x83em\x00\x00\x00\x05Hello\x00\x00\x04\xDD\x01', 'binary'))).toEqual(reference);

reference = {
"node" : "Hello",
"id": [10, 15, 1245],
"creation": 1
};
expect(erlpack.unpack(new Buffer('\x83r\x00\x03m\x00\x00\x00\x05Hello\x01\x00\x00\x00\x0A\x00\x00\x00\x0F\x00\x00\x04\xDD', 'binary'))).toEqual(reference);
expect(erlpack.unpack(Buffer.from('\x83r\x00\x03m\x00\x00\x00\x05Hello\x01\x00\x00\x00\x0A\x00\x00\x00\x0F\x00\x00\x04\xDD', 'binary'))).toEqual(reference);
});

it('port', () => {
Expand All @@ -142,7 +142,7 @@ describe('unpacks', () => {
"id": 1245,
"creation": 1
};
expect(erlpack.unpack(new Buffer('\x83fm\x00\x00\x00\x05Hello\x00\x00\x04\xDD\x01', 'binary'))).toEqual(port);
expect(erlpack.unpack(Buffer.from('\x83fm\x00\x00\x00\x05Hello\x00\x00\x04\xDD\x01', 'binary'))).toEqual(port);
});

it('pid', () => {
Expand All @@ -152,7 +152,7 @@ describe('unpacks', () => {
"serial": 123456,
"creation": 1
};
expect(erlpack.unpack(new Buffer('\x83gm\x00\x00\x00\x05Hello\x00\x00\x04\xDD\x00\x01\xE2\x40\x01', 'binary'))).toEqual(pid);
expect(erlpack.unpack(Buffer.from('\x83gm\x00\x00\x00\x05Hello\x00\x00\x04\xDD\x00\x01\xE2\x40\x01', 'binary'))).toEqual(pid);
});

it('export', () => {
Expand All @@ -161,11 +161,11 @@ describe('unpacks', () => {
"fun": "append",
"arity": 1
};
expect(erlpack.unpack(new Buffer('\x83qd\x00\x0Dguild_membersd\x00\x06appenda\x01', 'binary'))).toEqual(exp);
expect(erlpack.unpack(Buffer.from('\x83qd\x00\x0Dguild_membersd\x00\x06appenda\x01', 'binary'))).toEqual(exp);
});

it('can unpack from ArrayBuffers', () => {
const data = new Buffer('\x83k\x00\x0b' + helloWorldBinary, 'binary');
const data = Buffer.from('\x83k\x00\x0b' + helloWorldBinary, 'binary');
var byteBuffer = new Uint8Array(data.length);
for(var i = 0; i < data.length; ++i) {
byteBuffer[i] = data[i];
Expand All @@ -174,44 +174,44 @@ describe('unpacks', () => {
});

it('excepts from malformed token', () => {
const data = new Buffer(
const data = Buffer.from(
'\x83q\x00\x00\x00\x03a\x02a\x02a\x03l\x00\x00\x00\x03a\x01a\x02a\x03jm\x00\x00\x00\x01aa\x01',
'binary'
);
expect(() => erlpack.unpack(data)).toThrow("Unsupported erlang term type identifier found");
expect(() => erlpack.unpack(new Buffer('\x83k\x00', 'binary'))).toThrow("Reading two bytes passes the end of the buffer.");
expect(() => erlpack.unpack(Buffer.from('\x83k\x00', 'binary'))).toThrow("Reading two bytes passes the end of the buffer.");
});

it('excepts from malformed array', () => {
expect(() => erlpack.unpack(new Buffer('\x83t\x00\x00\x00\x03a\x02a\x02a\x03', 'binary'))).toThrow("Unpacking beyond the end of the buffer");
expect(() => erlpack.unpack(Buffer.from('\x83t\x00\x00\x00\x03a\x02a\x02a\x03', 'binary'))).toThrow("Unpacking beyond the end of the buffer");
});

it('excepts from malformed object', () => {
const data = new Buffer(
const data = Buffer.from(
'\x83t\x00\x00\x00\x04a\x02a\x02a\x03l\x00\x00\x00\x03a\x01a\x02a\x03jm\x00\x00\x00\x01aa\x01',
'binary'
);
expect(() => erlpack.unpack(data)).toThrow("Unpacking beyond the end of the buffer");
});

it('excepts from malformed atom', () => {
expect(() => erlpack.unpack(new Buffer('\x83s\x09true', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
expect(() => erlpack.unpack(Buffer.from('\x83s\x09true', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
});

it('excepts from malformed integer', () => {
expect(() => erlpack.unpack(new Buffer('\x83b\x00\x00\x04', 'binary'))).toThrow("Reading three bytes passes the end of the buffer.");
expect(() => erlpack.unpack(Buffer.from('\x83b\x00\x00\x04', 'binary'))).toThrow("Reading three bytes passes the end of the buffer.");
});

it('excepts from malformed float', () => {
expect(() => erlpack.unpack(new Buffer('\x83c2.500000000000000e+00\x00\x00\x00\x00\x00', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
expect(() => erlpack.unpack(Buffer.from('\x83c2.500000000000000e+00\x00\x00\x00\x00\x00', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
});

it('excepts from malformed string ', () => {
expect(() => erlpack.unpack(new Buffer('\x83k\x00\x0bworld', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
expect(() => erlpack.unpack(Buffer.from('\x83k\x00\x0bworld', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
});

it('excepts from malformed binary', () => {
expect(() => erlpack.unpack(new Buffer('\x83m\x00\x00\x00\x0chel', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
expect(() => erlpack.unpack(Buffer.from('\x83m\x00\x00\x00\x0chel', 'binary'))).toThrow("Reading sequence past the end of the buffer.");
});
});