'use strict'; const assert = require('assert'); const util = require('util'); const _ = require('lodash'); const lo = require('../lib/Layout'); /* Some versions of Node have an undocumented in-place reverse. * That's not what we want. */ function reversedBuffer(b) { const ba = Array.prototype.slice.call(b); return Buffer.from(ba.reverse()); } /* Helper to check that a thrown exception is both the expected type * and carries the expected message. */ function checkError(exc, expect, regex) { if (expect && !(exc instanceof expect)) { console.log('checkError failed: exc ' + typeof exc + ' expect ' + expect); return false; } if (regex && !exc.message.match(regex)) { console.log('checkError failed: msg "' + exc.message + '" nomatch ' + regex); return false; } return true; } suite('Layout', function() { test('#reversedBuffer', function() { const b = Buffer.from('0102030405', 'hex'); assert.equal(Buffer.from('0504030201', 'hex').compare(reversedBuffer(b)), 0); }); suite('Buffer', function() { test('issue 3992', function() { const buf = Buffer.alloc(4); buf.writeIntLE(-0x120000, 0, 4); assert.deepEqual(buf.toJSON().data, [0x00, 0x00, 0xee, 0xff]); buf.writeIntBE(-0x120000, 0, 4); assert.deepEqual(buf.toJSON().data, [0xff, 0xee, 0x00, 0x00]); }); }); suite('Layout', function() { test('anonymous ctor', function() { const d = new lo.Layout(8); assert(d instanceof lo.Layout); assert.equal(d.span, 8); assert.equal(d.getSpan(), d.span); assert.strictEqual(d.property, undefined); }); test('named ctor', function() { const d = new lo.Layout(8, 'tag'); assert(d instanceof lo.Layout); assert.equal(d.span, 8); assert.equal(d.getSpan(), d.span); assert.equal(d.property, 'tag'); }); test('invalid ctor', function() { assert.throws(() => new lo.Layout(), TypeError); assert.throws(() => new lo.Layout('3'), TypeError); assert.throws(() => new lo.Layout('three'), TypeError); }); test('abstractness', function() { const d = new lo.Layout(3); const b = Buffer.alloc(3); assert.throws(() => d.decode(b)); assert.throws(() => d.encode('sth', b)); }); test('#getSpan', function() { assert.equal((new lo.Layout(3)).getSpan(), 3); assert.throws(() => (new lo.Layout(-1)).getSpan(), RangeError); }); }); suite('UInt', function() { test('u8', function() { const d = lo.u8('t'); const b = Buffer.alloc(1); assert(d instanceof lo.UInt); assert(d instanceof lo.Layout); assert.equal(d.span, 1); assert.equal(d.getSpan(), d.span); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(23, b), 1); assert.equal(Buffer.from('17', 'hex').compare(b), 0); assert.equal(d.decode(b), 23); }); test('u16', function() { const d = lo.u16('t'); const b = Buffer.alloc(2); assert(d instanceof lo.UInt); assert(d instanceof lo.Layout); assert.equal(d.span, 2); assert.equal(d.getSpan(), d.span); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x1234, b), 2); assert.equal(Buffer.from('3412', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x1234); }); test('u24', function() { const d = lo.u24('t'); const b = Buffer.alloc(3); assert.equal(d.span, 3); assert.equal(0x563412, d.decode(Buffer.from('123456', 'hex'))); assert.throws(() => d.encode(0x1234567, b)); }); test('u48', function() { const d = lo.u48('t'); const b = Buffer.alloc(6); assert(d instanceof lo.UInt); assert(d instanceof lo.Layout); assert.equal(d.span, 6); assert.equal(d.getSpan(), d.span); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x123456789abc, b), 6); assert.equal(Buffer.from('bc9a78563412', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x123456789abc); }); test('offset', function() { const b = Buffer.alloc(4); b.fill(0xa5); const d = lo.u16('t'); d.encode(0x3412, b, 1); assert.equal(Buffer.from('A51234A5', 'hex').compare(b), 0); assert.equal(0xA534, d.decode(b, 2)); }); test('invalid ctor', function() { assert.throws(() => new lo.UInt(8), RangeError); }); }); suite('UIntBE', function() { test('u16be', function() { const d = lo.u16be('t'); const b = Buffer.alloc(2); assert(d instanceof lo.UIntBE); assert(d instanceof lo.Layout); assert.equal(d.span, 2); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x1234, b), 2); assert.equal(Buffer.from('1234', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x1234); }); test('u24be', function() { const d = lo.u24be('t'); const b = Buffer.alloc(3); assert.equal(d.span, 3); assert.equal(0x123456, d.decode(Buffer.from('123456', 'hex'))); assert.throws(() => d.encode(0x1234567, b)); assert.throws(() => d.encode(-1, b)); }); test('u32be', function() { const d = lo.u32be('t'); const b = Buffer.alloc(4); assert.equal(d.span, 4); assert.equal(0x12345678, d.decode(Buffer.from('12345678', 'hex'))); assert.throws(() => d.encode(0x123456789, b)); assert.throws(() => d.encode(-1, b)); }); test('u40be', function() { const d = lo.u40be('t'); const b = Buffer.alloc(5); assert.equal(d.span, 5); assert.equal(0x123456789a, d.decode(Buffer.from('123456789a', 'hex'))); assert.throws(() => d.encode(0x123456789ab, b)); assert.throws(() => d.encode(-1, b)); }); test('u48be', function() { const d = lo.u48be('t'); const b = Buffer.alloc(6); assert(d instanceof lo.UIntBE); assert(d instanceof lo.Layout); assert.equal(d.span, 6); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x123456789abc, b), 6); assert.equal(Buffer.from('123456789abc', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x123456789abc); }); test('offset', function() { const b = Buffer.alloc(4); b.fill(0xa5); const d = lo.u16be('t'); d.encode(0x1234, b, 1); assert.equal(Buffer.from('A51234A5', 'hex').compare(b), 0); assert.equal(0x34A5, d.decode(b, 2)); }); test('invalid ctor', function() { assert.throws(() => new lo.UIntBE(8), RangeError); }); }); suite('Int', function() { test('s8', function() { const d = lo.s8('t'); const b = Buffer.alloc(1); assert(d instanceof lo.Int); assert(d instanceof lo.Layout); assert.equal(d.span, 1); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(23, b), 1); assert.equal(Buffer.from('17', 'hex').compare(b), 0); assert.equal(d.decode(b), 23); assert.equal(d.encode(-97, b), 1); assert.equal(Buffer.from('9f', 'hex').compare(b), 0); assert.equal(d.decode(b), -97); }); test('s16', function() { const d = lo.s16('t'); const b = Buffer.alloc(2); assert(d instanceof lo.Int); assert(d instanceof lo.Layout); assert.equal(d.span, 2); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x1234, b), 2); assert.equal(Buffer.from('3412', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x1234); assert.equal(lo.u16be().decode(b), 0x3412); assert.equal(d.encode(-12345, b), 2); assert.equal(Buffer.from('c7cf', 'hex').compare(b), 0); assert.equal(d.decode(b), -12345); assert.equal(lo.u16().decode(b), 0xcfc7); assert.equal(lo.u16be().decode(b), 0xc7cf); }); test('s24', function() { const d = lo.s24('t'); const b = Buffer.alloc(3); assert.equal(d.span, 3); assert.equal(0x563412, d.decode(Buffer.from('123456', 'hex'))); assert.equal(-1, d.decode(Buffer.from('FFFFFF', 'hex'))); assert.equal(-0x800000, d.decode(Buffer.from('000080', 'hex'))); assert.throws(() => d.encode(0x800000, b)); assert.throws(() => d.encode(-0x800001, b)); }); test('s40', function() { const d = lo.s40('t'); const b = Buffer.alloc(5); assert.equal(d.span, 5); assert.equal(0x123456789a, d.decode(Buffer.from('9a78563412', 'hex'))); assert.equal(-1, d.decode(Buffer.from('FFFFFFFFFF', 'hex'))); assert.equal(-0x8000000000, d.decode(Buffer.from('0000000080', 'hex'))); assert.throws(() => d.encode(0x8000000000, b)); assert.throws(() => d.encode(-0x8000000001, b)); }); test('s48', function() { const d = lo.s48('t'); const b = Buffer.alloc(6); assert(d instanceof lo.Int); assert(d instanceof lo.Layout); assert.equal(d.span, 6); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x123456789abc, b), 6); assert.equal(Buffer.from('bc9a78563412', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x123456789abc); assert.equal(lo.u48be().decode(b), 0xbc9a78563412); assert.equal(d.encode(-123456789012345, b), 6); assert.equal(Buffer.from('8720f279b78f', 'hex').compare(b), 0); assert.equal(d.decode(b), -123456789012345); assert.equal(lo.u48().decode(b), 0x8fb779f22087); assert.equal(lo.u48be().decode(b), 0x8720f279b78f); }); test('invalid ctor', function() { assert.throws(() => new lo.Int(8), RangeError); }); }); suite('IntBE', function() { test('s16be', function() { const d = lo.s16be('t'); const b = Buffer.alloc(2); assert(d instanceof lo.IntBE); assert(d instanceof lo.Layout); assert.equal(d.span, 2); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x1234, b), 2); assert.equal(Buffer.from('1234', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x1234); assert.equal(lo.u16().decode(b), 0x3412); assert.equal(d.encode(-12345, b), 2); assert.equal(Buffer.from('cfc7', 'hex').compare(b), 0); assert.equal(d.decode(b), -12345); assert.equal(lo.u16be().decode(b), 0xcfc7); assert.equal(lo.u16().decode(b), 0xc7cf); }); test('s24be', function() { const d = lo.s24be('t'); const b = Buffer.alloc(3); assert.equal(d.span, 3); assert.equal(0x123456, d.decode(Buffer.from('123456', 'hex'))); assert.equal(-1, d.decode(Buffer.from('FFFFFF', 'hex'))); assert.equal(-0x800000, d.decode(Buffer.from('800000', 'hex'))); assert.throws(() => d.encode(0x800000, b)); assert.throws(() => d.encode(-0x800001, b)); }); test('s32be', function() { const d = lo.s32be('t'); const b = Buffer.alloc(4); assert.equal(d.span, 4); assert.equal(0x12345678, d.decode(Buffer.from('12345678', 'hex'))); assert.equal(-1, d.decode(Buffer.from('FFFFFFFF', 'hex'))); assert.equal(-0x80000000, d.decode(Buffer.from('80000000', 'hex'))); assert.throws(() => d.encode(0x80000000, b)); assert.throws(() => d.encode(-0x80000001, b)); }); test('s40be', function() { const d = lo.s40be('t'); const b = Buffer.alloc(5); assert.equal(d.span, 5); assert.equal(0x123456789a, d.decode(Buffer.from('123456789a', 'hex'))); assert.equal(-1, d.decode(Buffer.from('FFFFFFFFFF', 'hex'))); assert.equal(-0x8000000000, d.decode(Buffer.from('8000000000', 'hex'))); assert.throws(() => d.encode(0x8000000000, b)); assert.throws(() => d.encode(-0x8000000001, b)); }); test('s48be', function() { const d = lo.s48be('t'); const b = Buffer.alloc(6); assert(d instanceof lo.IntBE); assert(d instanceof lo.Layout); assert.equal(d.span, 6); assert.equal(d.property, 't'); b.fill(0); assert.equal(d.decode(b), 0); assert.equal(d.encode(0x123456789abc, b), 6); assert.equal(Buffer.from('123456789abc', 'hex').compare(b), 0); assert.equal(d.decode(b), 0x123456789abc); assert.equal(lo.u48().decode(b), 0xbc9a78563412); assert.equal(d.encode(-123456789012345, b), 6); assert.equal(Buffer.from('8fb779f22087', 'hex').compare(b), 0); assert.equal(d.decode(b), -123456789012345); assert.equal(lo.u48be().decode(b), 0x8fb779f22087); assert.equal(lo.u48().decode(b), 0x8720f279b78f); }); test('invalid ctor', function() { assert.throws(() => new lo.IntBE(8, 'u64'), RangeError); }); }); test('RoundedUInt64', function() { const be = lo.nu64be('be'); const le = lo.nu64('le'); assert.equal(be.span, 8); assert.equal(le.span, 8); assert.equal(be.property, 'be'); assert.equal(le.property, 'le'); let b = Buffer.from('0000003b2a2a873b', 'hex'); let rb = reversedBuffer(b); let v = 254110500667; let ev = v; const eb = Buffer.alloc(be.span); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(b.compare(eb), 0); assert.equal(le.encode(v, eb), 8); assert.equal(rb.compare(eb), 0); b = Buffer.from('001d9515553fdcbb', 'hex'); rb = reversedBuffer(b); v = 8326693181709499; ev = v; assert.equal(ev, v); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(b.compare(eb), 0); assert.equal(be.decode(eb), ev); assert.equal(le.encode(v, eb), 8); assert.equal(rb.compare(eb), 0); assert.equal(le.decode(eb), ev); /* The logic changes for the remaining cases since the exact * value cannot be represented in a Number: the encoded buffer * will not bitwise-match the original buffer. */ b = Buffer.from('003b2a2aaa7fdcbb', 'hex'); rb = reversedBuffer(b); v = 16653386363428027; ev = v + 1; assert.equal(ev, v); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(be.decode(eb), ev); assert.equal(le.encode(v, eb), 8); assert.equal(le.decode(eb), ev); b = Buffer.from('eca8aaa9ffffdcbb', 'hex'); rb = reversedBuffer(b); v = 17053067636159536315; ev = v + 837; assert.equal(ev, v); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(be.decode(eb), ev); assert.equal(le.encode(v, eb), 8); assert.equal(le.decode(eb), ev); b = Buffer.alloc(10); b.fill(0xa5); le.encode(1, b, 1); assert.equal(Buffer.from('a50100000000000000a5', 'hex').compare(b), 0); assert.equal(1, le.decode(b, 1)); be.encode(1, b, 1); assert.equal(Buffer.from('a50000000000000001a5', 'hex').compare(b), 0); assert.equal(1, be.decode(b, 1)); }); test('RoundedInt64', function() { const be = lo.ns64be('be'); const le = lo.ns64('le'); assert.equal(be.span, 8); assert.equal(le.span, 8); assert.equal(be.property, 'be'); assert.equal(le.property, 'le'); let b = Buffer.from('ffffffff89abcdf0', 'hex'); let rb = reversedBuffer(b); let v = -1985229328; let ev = v; const eb = Buffer.alloc(be.span); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(b.compare(eb), 0); assert.equal(le.encode(v, eb), 8); assert.equal(rb.compare(eb), 0); b = Buffer.from('ffffc4d5d555a345', 'hex'); rb = reversedBuffer(b); v = -65052290473147; ev = v; assert.equal(ev, v); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(b.compare(eb), 0); assert.equal(be.decode(eb), ev); assert.equal(le.encode(v, eb), 8); assert.equal(rb.compare(eb), 0); assert.equal(le.decode(eb), ev); /* The logic changes for the remaining cases since the exact * value cannot be represented in a Number: the encoded buffer * will not bitwise-match the original buffer. */ b = Buffer.from('ff13575556002345', 'hex'); rb = reversedBuffer(b); v = -66613545453739195; ev = v + 3; assert.equal(ev, v); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(be.decode(eb), ev); assert.equal(le.encode(v, eb), 8); assert.equal(le.decode(eb), ev); b = Buffer.from('e26aeaaac0002345', 'hex'); rb = reversedBuffer(b); v = -2131633454519934139; ev = v - 69; assert.equal(ev, v); assert.equal(be.decode(b), ev); assert.equal(le.decode(rb), ev); assert.equal(be.encode(v, eb), 8); assert.equal(be.decode(eb), ev); assert.equal(le.encode(v, eb), 8); assert.equal(le.decode(eb), ev); b = Buffer.alloc(10); b.fill(0xa5); le.encode(1, b, 1); assert.equal(Buffer.from('a50100000000000000a5', 'hex').compare(b), 0); assert.equal(1, le.decode(b, 1)); be.encode(1, b, 1); assert.equal(Buffer.from('a50000000000000001a5', 'hex').compare(b), 0); assert.equal(1, be.decode(b, 1)); assert.equal(le.decode(Buffer.from('0000007001000000', 'hex')), 6174015488); assert.equal(le.decode(Buffer.from('0000008001000000', 'hex')), 6442450944); }); test('Float', function() { const be = lo.f32be('eff'); const le = lo.f32('ffe'); const f = 123456.125; const fe = 3.174030951333261e-29; let b = Buffer.alloc(4); assert(be instanceof lo.FloatBE); assert(be instanceof lo.Layout); assert.equal(be.span, 4); assert.equal(be.getSpan(), be.span); assert.equal(be.property, 'eff'); assert(le instanceof lo.Float); assert(le instanceof lo.Layout); assert.equal(le.span, 4); assert.equal(le.property, 'ffe'); b.fill(0); assert.equal(be.decode(b), 0); assert.equal(le.decode(b), 0); assert.equal(le.encode(f, b), 4); assert.equal(Buffer.from('1020f147', 'hex').compare(b), 0); assert.equal(le.decode(b), f); assert.equal(be.decode(b), fe); assert.equal(be.encode(f, b), 4); assert.equal(Buffer.from('47f12010', 'hex').compare(b), 0); assert.equal(be.decode(b), f); assert.equal(le.decode(b), fe); b = Buffer.alloc(6); b.fill(0xa5); le.encode(f, b, 1); assert.equal(Buffer.from('a51020f147a5', 'hex').compare(b), 0); assert.equal(f, le.decode(b, 1)); be.encode(f, b, 1); assert.equal(Buffer.from('a547f12010a5', 'hex').compare(b), 0); assert.equal(f, be.decode(b, 1)); }); test('Double', function() { const be = lo.f64be('dee'); const le = lo.f64('eed'); const f = 123456789.125e+10; const fe = 3.4283031083405533e-77; let b = Buffer.alloc(8); assert(be instanceof lo.DoubleBE); assert(be instanceof lo.Layout); assert.equal(be.span, 8); assert.equal(be.property, 'dee'); assert(le instanceof lo.Double); assert(le instanceof lo.Layout); assert.equal(le.span, 8); assert.equal(le.property, 'eed'); b.fill(0); assert.equal(be.decode(b), 0); assert.equal(le.decode(b), 0); assert.equal(le.encode(f, b), 8); assert.equal(Buffer.from('300fc1f41022b143', 'hex').compare(b), 0); assert.equal(le.decode(b), f); assert.equal(be.decode(b), fe); assert.equal(be.encode(f, b), 8); assert.equal(Buffer.from('43b12210f4c10f30', 'hex').compare(b), 0); assert.equal(be.decode(b), f); assert.equal(le.decode(b), fe); b = Buffer.alloc(10); b.fill(0xa5); le.encode(f, b, 1); assert.equal(Buffer.from('a5300fc1f41022b143a5', 'hex').compare(b), 0); assert.equal(f, le.decode(b, 1)); be.encode(f, b, 1); assert.equal(Buffer.from('a543b12210f4c10f30a5', 'hex').compare(b), 0); assert.equal(f, be.decode(b, 1)); }); suite('Sequence', function() { test('invalid ctor', function() { assert.throws(() => new lo.Sequence(), TypeError); assert.throws(() => new lo.Sequence(lo.u8()), TypeError); assert.throws(() => new lo.Sequence(lo.u8(), '5 is not an integer'), TypeError); assert.throws(() => new lo.Sequence(lo.u8(), lo.u8()), TypeError); assert.throws(() => new lo.Sequence(lo.u8(), lo.offset(lo.f32())), TypeError); }); test('basics', function() { const seq = new lo.Sequence(lo.u8(), 4, 'id'); const b = Buffer.alloc(4); assert(seq instanceof lo.Sequence); assert(seq instanceof lo.Layout); assert(seq.elementLayout instanceof lo.UInt); assert.equal(seq.count, 4); assert.equal(seq.span, 4); assert.equal(seq.getSpan(), seq.span); assert.equal(seq.property, 'id'); b.fill(0); assert.deepEqual(seq.decode(b), [0, 0, 0, 0]); assert.equal(seq.encode([1, 2, 3, 4], b), 4); assert.deepEqual(seq.decode(b), [1, 2, 3, 4]); assert.equal(seq.encode([5, 6], b, 1), 2); assert.deepEqual(seq.decode(b), [1, 5, 6, 4]); }); test('in struct', function() { const seq = lo.seq(lo.u8(), 4, 'id'); const str = lo.struct([seq]); const d = str.decode(Buffer.from('01020304', 'hex')); assert.deepEqual(d, {id: [1, 2, 3, 4]}); }); test('struct elts', function() { const st = new lo.Structure([lo.u8('u8'), lo.s32('s32')]); const seq = new lo.Sequence(st, 3); const tv = [{u8: 1, s32: 1e4}, {u8: 0, s32: 0}, {u8: 3, s32: -324}]; const b = Buffer.alloc(15); assert.equal(st.span, 5); assert.equal(seq.count, 3); assert.strictEqual(seq.elementLayout, st); assert.equal(seq.span, 15); assert.equal(seq.encode(tv, b), seq.span); assert.equal(Buffer.from('0110270000000000000003bcfeffff', 'hex').compare(b), 0); assert.deepEqual(seq.decode(b), tv); assert.equal(seq.encode([{u8: 2, s32: 0x12345678}], b, st.span), 1 * st.span); assert.equal(Buffer.from('0110270000027856341203bcfeffff', 'hex').compare(b), 0); }); test('const count', function() { const clo = lo.u8('n'); const seq = lo.seq(lo.u8(), lo.offset(clo, -1), 'a'); const st = lo.struct([clo, seq]); let b = Buffer.from('03010203', 'hex'); let obj = st.decode(b); assert.equal(obj.n, 3); assert.deepEqual(obj.a, [1, 2, 3]); b = Buffer.alloc(10); obj = {n: 3, a: [5, 6, 7, 8, 9]}; assert.equal(st.encode(obj, b), 6); const span = st.getSpan(b); assert.equal(span, 6); assert.equal(Buffer.from('050506070809', 'hex').compare(b.slice(0, span)), 0); }); // For variable span alone see CString in seq test('const count+span', function() { const clo = lo.u8('n'); const seq = lo.seq(lo.cstr(), lo.offset(clo, -1), 'a'); const st = lo.struct([clo, seq]); let b = Buffer.from('036100620063646500', 'hex'); let obj = st.decode(b); assert.equal(obj.n, 3); assert.deepEqual(obj.a, ['a', 'b', 'cde']); b = Buffer.alloc(10); obj = {n: 6, a: ['one', 'two']}; assert.equal(st.encode(obj, b), clo.span + 8); const span = st.getSpan(b); assert.equal(span, 9); assert.equal(Buffer.from('026f6e650074776f00', 'hex') .compare(b.slice(0, span)), 0); }); test('zero-count', function() { const seq = lo.seq(lo.u8(), 0); const b = Buffer.from('', 'hex'); assert.equal(seq.span, 0); assert.deepEqual(seq.decode(b), []); }); test('greedy', function() { const seq = lo.seq(lo.u16(), lo.greedy(2), 'a'); const b = Buffer.from('ABCDE'); const db = Buffer.alloc(6); assert.equal(seq.getSpan(b), 4); assert.deepEqual(seq.decode(b), [0x4241, 0x4443]); db.fill('-'.charAt(0)); assert.equal(seq.encode(seq.decode(b), db, 1), 4); assert.equal(Buffer.from('-ABCD-').compare(db), 0); assert.equal(seq.getSpan(b, 1), 4); assert.deepEqual(seq.decode(b, 1), [0x4342, 0x4544]); }); }); suite('Structure', function() { test('invalid ctor', function() { assert.throws(() => new lo.Structure(), TypeError); assert.throws(() => new lo.Structure('stuff'), TypeError); assert.throws(() => new lo.Structure(['stuff']), TypeError); // no unnamed variable-length fields assert.throws(() => new lo.Structure([lo.cstr()]), err => checkError(err, Error, /cannot contain unnamed variable-length layout/)); }); test('basics', function() { const st = new lo.Structure([lo.u8('u8'), lo.u16('u16'), lo.s16be('s16be')]); const b = Buffer.alloc(5); assert(st instanceof lo.Structure); assert(st instanceof lo.Layout); assert.equal(st.span, 5); assert.equal(st.getSpan(), st.span); assert.strictEqual(st.property, undefined); b.fill(0); let obj = st.decode(b); assert.deepEqual(obj, {u8: 0, u16: 0, s16be: 0}); obj = {u8: 21, u16: 0x1234, s16be: -5432}; assert.equal(st.encode(obj, b), st.span); assert.equal(Buffer.from('153412eac8', 'hex').compare(b), 0); assert.deepEqual(st.decode(b), obj); }); test('padding', function() { const st = new lo.Structure([lo.u16('u16'), lo.u8(), lo.s16be('s16be')]); const b = Buffer.alloc(5); assert.equal(st.span, 5); b.fill(0); let obj = st.decode(b); assert.deepEqual(obj, {u16: 0, s16be: 0}); b.fill(0xFF); obj = {u16: 0x1234, s16be: -5432}; assert.equal(st.encode(obj, b), st.span); assert.equal(Buffer.from('3412ffeac8', 'hex').compare(b), 0); assert.deepEqual(st.decode(b), obj); }); test('missing', function() { const st = new lo.Structure([lo.u16('u16'), lo.u8('u8'), lo.s16be('s16be')]); const b = Buffer.alloc(5); assert.equal(st.span, 5); b.fill(0); let obj = st.decode(b); assert.deepEqual(obj, {u16: 0, u8: 0, s16be: 0}); b.fill(0xa5); obj = {u16: 0x1234, s16be: -5432}; assert.equal(st.encode(obj, b), st.span); assert.equal(Buffer.from('3412a5eac8', 'hex').compare(b), 0); assert.deepEqual(st.decode(b), _.extend(obj, {u8: 0xa5})); }); test('update', function() { const st = new lo.Structure([lo.u8('u8'), lo.u16('u16'), lo.s16be('s16be')]); const b = Buffer.from('153412eac8', 'hex'); const rc = st.decode(b, 0); assert.deepEqual(rc, {u8: 21, u16: 0x1234, s16be: -5432}); }); test('nested', function() { const st = new lo.Structure([lo.u8('u8'), lo.u16('u16'), lo.s16be('s16be')], 'st'); const cst = new lo.Structure([lo.u32('u32'), st, lo.s24('s24')]); const obj = {u32: 0x12345678, st: { u8: 23, u16: 65432, s16be: -12345, }, s24: -123456}; const b = Buffer.alloc(12); assert.equal(st.span, 5); assert.equal(st.property, 'st'); assert.equal(cst.span, 12); assert.equal(cst.encode(obj, b), cst.span); assert.equal(Buffer.from('785634121798ffcfc7c01dfe', 'hex').compare(b), 0); assert.deepEqual(cst.decode(b), obj); }); test('empty', function() { const st = lo.struct([], 'st'); const b = Buffer.from('', 'hex'); assert.equal(st.span, 0); assert.deepEqual(st.decode(b), {}); }); test('offset-variant', function() { const st = lo.struct([lo.cstr('s')], 'st'); assert(0 > st.span); const b = Buffer.alloc(5); b.fill(0xa5); const obj = {s: 'ab'}; st.encode(obj, b, 1); assert.equal(Buffer.from('a5616200a5', 'hex').compare(b), 0); assert.equal(3, st.getSpan(b, 1)); assert.deepEqual(st.decode(b, 1), obj); }); test('empty encode fixed span', function() { const slo = lo.struct([lo.u8('a'), lo.u8('b')]); assert.equal(slo.span, 2); const b = Buffer.alloc(10); assert.equal(slo.encode({}, b), slo.span); assert.equal(slo.encode({}, b, 1), slo.span); }); test('empty encode variable span', function() { const slo = lo.struct([lo.u8('a'), lo.cstr('s')]); assert.equal(slo.span, -1); const b = Buffer.alloc(10); assert.equal(slo.encode({}, b), 1); assert.equal(slo.encode({}, b, 5), 1); assert.equal(slo.encode({a: 5}, b), 1); assert.equal(slo.encode({a: 5, s: 'hi'}, b), 4); assert.equal(slo.encode({a: 5, s: 'hi'}, b, 5), 4); }); suite('prefix decoding', function() { const fields = [ lo.u32('u32'), lo.u16('u16'), lo.u8('u8'), ]; const b = Buffer.from('01020304111221', 'hex'); test('rejects partial by default', function() { const slo = lo.struct(fields); assert.strictEqual(slo.decodePrefixes, false); assert.deepEqual(slo.decode(b), { u32: 0x04030201, u16: 0x1211, u8: 0x21, }); assert.throws(() => slo.decode(b.slice(0, 4)), RangeError); }); test('accepts full fields if enabled', function() { const slo = lo.struct(fields, true); assert.strictEqual(slo.decodePrefixes, true); assert.deepEqual(slo.decode(b), { u32: 0x04030201, u16: 0x1211, u8: 0x21, }); assert.deepEqual(slo.decode(b.slice(0, 4)), { u32: 0x04030201, }); assert.deepEqual(slo.decode(b.slice(0, 6)), { u32: 0x04030201, u16: 0x1211, }); assert.throws(() => slo.decode(b.slice(0, 3)), RangeError); }); test('preserved by replicate', function() { const property = 'name'; const slo = lo.struct(fields, property, true); assert.strictEqual(slo.property, property); assert.strictEqual(slo.decodePrefixes, true); const slo2 = slo.replicate('other'); assert.strictEqual(slo2.property, 'other'); assert.strictEqual(slo2.decodePrefixes, true); }); }); }); suite('replicate', function() { test('uint', function() { const src = lo.u32('hi'); const dst = src.replicate('lo'); assert(dst instanceof src.constructor); assert.equal(dst.span, src.span); assert.equal(dst.property, 'lo'); }); test('struct', function() { const src = new lo.Structure([lo.u8('a'), lo.s32('b')], 'hi'); const dst = src.replicate('lo'); assert(dst instanceof src.constructor); assert.equal(dst.span, src.span); assert.strictEqual(dst.fields, src.fields); assert.equal(dst.property, 'lo'); }); test('sequence', function() { const src = new lo.Sequence(lo.u16(), 20, 'hi'); const dst = src.replicate('lo'); assert(dst instanceof src.constructor); assert.equal(dst.span, src.span); assert.equal(dst.count, src.count); assert.strictEqual(dst.elementLayout, src.elementLayout); assert.equal(dst.property, 'lo'); }); test('add', function() { const src = lo.u32(); const dst = src.replicate('p'); assert(dst instanceof src.constructor); assert.strictEqual(src.property, undefined); assert.equal(dst.property, 'p'); }); test('remove', function() { const src = lo.u32('p'); const dst = src.replicate(); assert(dst instanceof src.constructor); assert.equal(src.property, 'p'); assert.strictEqual(dst.property, undefined); }); test('layoutFor', function() { const u8 = lo.u8('u8'); const s32 = lo.s32('s32'); const cstr = lo.cstr('cstr'); const u16 = lo.u16('u16'); const d = lo.struct([u8, s32, cstr, u16], 's'); assert.throws(() => d.layoutFor(), err => ('property must be string' === err.message)); assert.strictEqual(d.layoutFor('u8'), u8); assert.strictEqual(d.layoutFor('cstr'), cstr); assert.strictEqual(d.layoutFor('other'), undefined); }); test('nameWithProperty', function() { const s32 = lo.s32('s32'); const u16 = lo.u16('u16'); const d = lo.struct([s32, lo.u16(), u16], 's'); assert.equal(lo.nameWithProperty('struct', d), 'struct[s]'); assert.equal(lo.nameWithProperty('pfx', d.fields[1]), 'pfx'); }); test('offsetOf', function() { const u8 = lo.u8('u8'); const s32 = lo.s32('s32'); const cstr = lo.cstr('cstr'); const u16 = lo.u16('u16'); const d = lo.struct([u8, s32, cstr, u16], 's'); assert.throws(() => d.offsetOf(), err => ('property must be string' === err.message)); assert.strictEqual(d.offsetOf('u8'), 0); assert.strictEqual(d.offsetOf('s32'), 1); assert.strictEqual(d.offsetOf('cstr'), 5); assert(0 > d.offsetOf('u16')); assert.strictEqual(d.offsetOf('other'), undefined); }); }); suite('VariantLayout', function() { test('invalid ctor', function() { const un = new lo.Union(lo.u8(), lo.u32()); assert.throws(() => new lo.VariantLayout(), TypeError); assert.throws(() => new lo.VariantLayout('other'), TypeError); assert.throws(() => new lo.VariantLayout(un), TypeError); assert.throws(() => new lo.VariantLayout(un, 1.2), TypeError); assert.throws(() => new lo.VariantLayout(un, 'str'), TypeError); assert.throws(() => new lo.VariantLayout(un, 1, lo.f64()), Error); assert.throws(() => new lo.VariantLayout(un, 1, lo.f32()), TypeError); assert.throws(() => new lo.VariantLayout(un, 1, 23), TypeError); }); test('ctor', function() { const un = new lo.Union(lo.u8(), lo.u32()); const d = new lo.VariantLayout(un, 1, lo.f32(), 'd'); assert(d instanceof lo.VariantLayout); assert(d instanceof lo.Layout); assert.strictEqual(d.union, un); assert.equal(d.span, 5); assert.equal(d.variant, 1); assert.equal(d.property, 'd'); }); test('ctor without layout', function() { const un = new lo.Union(lo.u8(), lo.u32()); const v0 = new lo.VariantLayout(un, 0); assert.strictEqual(v0.union, un); assert.equal(v0.span, 5); assert.strictEqual(v0.layout, null); assert.equal(v0.variant, 0); assert.equal(v0.property, undefined); const v1 = new lo.VariantLayout(un, 1, 'nul'); assert.strictEqual(v1.union, un); assert.equal(v1.span, 5); assert.strictEqual(v1.layout, null); assert.equal(v1.variant, 1); assert.equal(v1.property, 'nul'); }); test('span', function() { const un = new lo.Union(lo.u8(), lo.u32()); const d = new lo.VariantLayout(un, 1, lo.cstr(), 's'); const b = Buffer.alloc(12); assert.equal(d.encode({s: 'hi!'}, b), 5); assert.equal(un.getSpan(b), 5); assert.equal(Buffer.from('0168692100', 'hex').compare(b.slice(0, 5)), 0); // This one overruns the Buffer assert.throws(() => d.encode({s: 'far too long'}, b), RangeError); // This one fits in the buffer but overruns the union assert.throws(() => d.encode({s: 'too long'}, b), Error); }); }); suite('ExternalLayout', function() { test('ctor', function() { const el = new lo.ExternalLayout(-1, 'prop'); assert(el instanceof lo.ExternalLayout); assert(el instanceof lo.Layout); assert.equal(el.property, 'prop'); assert.throws(() => el.isCount(), Error); }); }); suite('GreedyCount', function() { test('ctor', function() { const el = lo.greedy(); assert(el instanceof lo.GreedyCount); assert(el instanceof lo.ExternalLayout); assert.equal(el.elementSpan, 1); assert.strictEqual(el.property, undefined); const nel = lo.greedy(5, 'name'); assert(nel instanceof lo.GreedyCount); assert(nel instanceof lo.ExternalLayout); assert.equal(nel.elementSpan, 5); assert.equal(nel.property, 'name'); assert.throws(() => lo.greedy('hi'), TypeError); assert.throws(() => lo.greedy(0), TypeError); }); test('#decode', function() { const el = lo.greedy(); const b = Buffer.alloc(10); assert.equal(el.decode(b), b.length); assert.equal(el.decode(b, 3), b.length - 3); const nel = lo.greedy(3); assert.equal(nel.decode(b), 3); assert.equal(nel.decode(b, 1), 3); assert.equal(nel.decode(b, 2), 2); }); }); suite('OffsetLayout', function() { test('ctor', function() { const u8 = lo.u8(); const l0 = new lo.OffsetLayout(u8); assert(l0 instanceof lo.OffsetLayout); assert(l0 instanceof lo.ExternalLayout); const nl = new lo.OffsetLayout(u8, -3, 'nl'); const dl = new lo.OffsetLayout(lo.u8('ol'), 5); const al = new lo.OffsetLayout(u8, 21); assert.strictEqual(l0.layout, u8); assert.equal(l0.offset, 0); assert.strictEqual(l0.property, undefined); assert.strictEqual(nl.layout, u8); assert.equal(nl.offset, -3); assert.equal(nl.property, 'nl'); assert.equal(dl.offset, 5); assert.equal(dl.property, 'ol'); assert.strictEqual(al.layout, u8); assert.equal(al.offset, 21); assert.strictEqual(al.property, undefined); }); test('codec', function() { const u8 = lo.u8(); const bl = lo.offset(u8, -1, 'bl'); const al = lo.offset(u8, 1, 'al'); const b = Buffer.from('0001020304050607', 'hex'); assert.equal(u8.decode(b), 0); assert.equal(al.decode(b), 1); assert.throws(() => bl.decode(b), RangeError); assert.equal(u8.decode(b, 4), 4); assert.equal(al.decode(b, 4), 5); assert.equal(bl.decode(b, 4), 3); assert.equal(u8.encode(0x80, b), 1); assert.equal(al.encode(0x91, b), 1); assert.throws(() => bl.encode(0x70, b), RangeError); assert.equal(u8.encode(0x84, b, 4), 1); assert.equal(al.encode(0x94, b, 4), 1); assert.equal(bl.encode(0x74, b, 4), 1); assert.equal(Buffer.from('8091027484940607', 'hex').compare(b), 0); }); test('invalid ctor', function() { assert.throws(() => new lo.OffsetLayout('hi'), TypeError); assert.throws(() => new lo.OffsetLayout(lo.u8(), 'hi'), TypeError); }); }); suite('UnionDiscriminator', function() { test('abstract', function() { const ud = new lo.UnionDiscriminator('p'); assert.equal(ud.property, 'p'); assert.throws(() => ud.decode(Buffer.from('00', 'hex')), Error); assert.throws(() => ud.encode(0, Buffer.alloc(1)), Error); }); }); suite('UnionLayoutDiscriminator', function() { test('invalid ctor', function() { assert.throws(() => new lo.UnionLayoutDiscriminator('hi'), TypeError); assert.throws(() => lo.unionLayoutDiscriminator('hi'), TypeError); assert.throws(() => new lo.UnionLayoutDiscriminator(lo.f32()), TypeError); assert.throws(() => { new lo.UnionLayoutDiscriminator(lo.u8(), 'hi'); }, TypeError); }); }); suite('Union', function() { test('invalid ctor', function() { assert.throws(() => new lo.Union(), TypeError); assert.throws(() => new lo.Union('other'), TypeError); assert.throws(() => new lo.Union(lo.f32()), TypeError); assert.throws(() => new lo.Union(lo.u8(), 'other'), TypeError); assert.throws(() => new lo.Union(lo.u8(), lo.cstr()), Error); }); test('basics', function() { const dlo = lo.u8(); const vlo = new lo.Sequence(lo.u8(), 8); const un = new lo.Union(dlo, vlo); const clo = un.defaultLayout; const b = Buffer.alloc(9); assert(un instanceof lo.Union); assert(un instanceof lo.Layout); assert.equal(un.span, 9); assert.equal(un.getSpan(), un.span); assert(un.usesPrefixDiscriminator); assert(un.discriminator instanceof lo.UnionLayoutDiscriminator); assert.notStrictEqual(clo, vlo); assert(clo instanceof vlo.constructor); assert.equal(clo.count, vlo.count); assert.strictEqual(clo.elementLayout, vlo.elementLayout); assert.equal(un.discriminator.property, 'variant'); assert.equal(un.defaultLayout.property, 'content'); assert.equal(dlo.span + vlo.span, un.span); assert.strictEqual(un.property, undefined); b.fill(0); const o = un.decode(b); assert.equal(o.variant, 0); assert.deepEqual(o.content, [0, 0, 0, 0, 0, 0, 0, 0]); o.variant = 5; o.content[3] = 3; o.content[7] = 7; assert.equal(un.encode(o, b), dlo.span + vlo.span); assert.equal(Buffer.from('050000000300000007', 'hex').compare(b), 0); }); test('variants', function() { const dlo = lo.u8('v'); const vlo = new lo.Sequence(lo.u8(), 4, 'c'); const un = new lo.Union(dlo, vlo); const b = Buffer.alloc(5); assert.strictEqual(un.getVariant(1), undefined); b.fill(0); assert.deepEqual(un.decode(b), {v: 0, c: [0, 0, 0, 0]}); const lo1 = lo.u32(); const v1 = un.addVariant(1, lo1, 'v1'); assert(v1 instanceof lo.VariantLayout); assert.equal(v1.variant, 1); assert.strictEqual(v1.layout, lo1); b.fill(1); assert.strictEqual(un.getVariant(b), v1); assert.deepEqual(v1.decode(b), {v1: 0x01010101}); assert.deepEqual(un.decode(b), {v1: 0x01010101}); const lo2 = lo.f32(); const v2 = un.addVariant(2, lo2, 'v2'); assert.equal(un.discriminator.encode(v2.variant, b), dlo.span); assert.strictEqual(un.getVariant(b), v2); assert.deepEqual(v2.decode(b), {v2: 2.3694278276172396e-38}); assert.deepEqual(un.decode(b), {v2: 2.3694278276172396e-38}); const lo3 = new lo.Structure([lo.u8('a'), lo.u8('b'), lo.u16('c')]); const v3 = un.addVariant(3, lo3, 'v3'); assert.equal(un.discriminator.encode(v3.variant, b), dlo.span); assert.strictEqual(un.getVariant(b), v3); assert.deepEqual(v3.decode(b), {v3: {a: 1, b: 1, c: 257}}); assert.deepEqual(un.decode(b), {v3: {a: 1, b: 1, c: 257}}); assert.equal(un.discriminator.encode(v2.variant, b), dlo.span); assert.equal(Buffer.from('0201010101', 'hex').compare(b), 0); const obj = {v3: {a: 5, b: 6, c: 1540}}; assert.equal(lo3.encode(obj.v3, b), lo3.span); assert.equal(v3.encode(obj, b), un.span); assert.notEqual(un.span, vlo.span + lo3.span); assert.deepEqual(un.decode(b), obj); assert.equal(Buffer.from('0305060406', 'hex').compare(b), 0); assert.throws(() => v2.encode(obj, b), TypeError); assert.throws(() => v2.decode(b), Error); const v0 = un.addVariant(0, 'v0'); assert.equal(un.discriminator.encode(v0.variant, b), dlo.span); assert.strictEqual(un.getVariant(b), v0); assert.deepEqual(un.decode(b), {v0: true}); }); test('custom default', function() { const dlo = lo.u8('number'); const vlo = new lo.Sequence(lo.u8(), 8, 'payload'); const un = new lo.Union(dlo, vlo); assert(un instanceof lo.Union); assert(un instanceof lo.Layout); assert(un.usesPrefixDiscriminator); assert(un.discriminator instanceof lo.UnionLayoutDiscriminator); assert.equal(un.discriminator.property, dlo.property); assert.equal(un.discriminator.layout.offset, 0); assert.strictEqual(un.defaultLayout, vlo); assert.equal(un.discriminator.property, 'number'); assert.equal(un.defaultLayout.property, 'payload'); }); test('inStruct', function() { const dlo = lo.u8('uid'); const vlo = new lo.Sequence(lo.u8(), 3, 'payload'); const un = new lo.Union(dlo, vlo, 'u'); const st = new lo.Structure([lo.u16('u16'), un, lo.s16('s16')]); const b = Buffer.from('0001020304050607', 'hex'); const obj = st.decode(b); assert.equal(obj.u16, 0x0100); assert.equal(obj.u.uid, 2); assert.deepEqual(obj.u.payload, [3, 4, 5]); assert.equal(obj.s16, 1798); obj.u16 = 0x5432; obj.s16 = -3; obj.u.payload[1] = 23; const b2 = Buffer.alloc(st.span); assert.equal(st.encode(obj, b2), st.span); assert.equal(Buffer.from('325402031705fdff', 'hex').compare(b2), 0); }); test('issue#6', function() { const dlo = lo.u8('number'); const vlo = new lo.Sequence(lo.u8(), 8, 'payload'); const un = new lo.Union(dlo, vlo); const b = Buffer.from('000102030405060708', 'hex'); const obj = un.decode(b); assert.equal(obj.number, 0); assert.deepEqual(obj.payload, [1, 2, 3, 4, 5, 6, 7, 8]); const b2 = Buffer.alloc(un.span); assert.equal(un.encode(obj, b2), dlo.span + vlo.span); assert.equal(b2.toString('hex'), b.toString('hex')); const obj2 = {variant: obj.number, content: obj.payload}; assert.throws(() => un.encode(obj2, b2)); }); test('issue#7.internal.anon', function() { const dlo = lo.u8(); const plo = new lo.Sequence(lo.u8(), 8, 'payload'); const vlo = new lo.Structure([plo, dlo]); const un = new lo.Union(lo.offset(dlo, plo.span), vlo); const clo = un.defaultLayout; const b = Buffer.from('000102030405060708', 'hex'); const obj = un.decode(b); assert(!un.usesPrefixDiscriminator); assert(un.discriminator instanceof lo.UnionLayoutDiscriminator); assert.equal(un.discriminator.property, 'variant'); assert.equal(un.defaultLayout.property, 'content'); assert.notStrictEqual(clo, vlo); assert(clo instanceof vlo.constructor); assert.strictEqual(clo.fields, vlo.fields); assert.deepEqual(obj.content, {payload: [0, 1, 2, 3, 4, 5, 6, 7]}); assert.equal(obj.variant, 8); }); test('issue#7.internal.named', function() { const dlo = lo.u8(); const plo = new lo.Sequence(lo.u8(), 8, 'payload'); const vlo = new lo.Structure([plo, dlo]); const ud = new lo.UnionLayoutDiscriminator(lo.offset(dlo, plo.span), 'tag'); const un = new lo.Union(ud, vlo); const clo = un.defaultLayout; const b = Buffer.from('000102030405060708', 'hex'); const obj = un.decode(b); assert(!un.usesPrefixDiscriminator); assert(un.discriminator instanceof lo.UnionLayoutDiscriminator); assert.equal(un.discriminator.property, 'tag'); assert.equal(clo.property, 'content'); assert.notStrictEqual(clo, vlo); assert(clo instanceof vlo.constructor); assert.strictEqual(clo.fields, vlo.fields); assert.deepEqual(obj.content, {payload: [0, 1, 2, 3, 4, 5, 6, 7]}); assert.equal(obj.tag, 8); assert.equal(9, un.getSpan(b)); }); test('issue#7.internal.named2', function() { const dlo = lo.u8('vid'); const plo = new lo.Sequence(lo.u8(), 8, 'payload'); const vlo = new lo.Structure([plo, dlo]); const un = new lo.Union(lo.offset(dlo, plo.span), vlo); const clo = un.defaultLayout; const b = Buffer.from('000102030405060708', 'hex'); const obj = un.decode(b); assert(!un.usesPrefixDiscriminator); assert(un.discriminator instanceof lo.UnionLayoutDiscriminator); assert.equal(un.discriminator.property, 'vid'); assert.equal(clo.property, 'content'); assert.notStrictEqual(clo, vlo); assert(clo instanceof vlo.constructor); assert.strictEqual(clo.fields, vlo.fields); assert.deepEqual(obj.content, {payload: [0, 1, 2, 3, 4, 5, 6, 7], vid: 8}); assert.equal(obj.vid, 8); }); test('issue#7.external', function() { const dlo = lo.u8('vid'); const ud = new lo.UnionLayoutDiscriminator(lo.offset(dlo, -3), 'uid'); const un = new lo.Union(ud, lo.u32('u32'), 'u'); const st = new lo.Structure([dlo, lo.u16('u16'), un, lo.s16('s16')]); assert.equal(un.span, 4); assert.equal(st.span, 9); const b = Buffer.from('000102030405060708', 'hex'); let obj = st.decode(b); assert.equal(obj.vid, 0); assert.equal(obj.u16, 0x201); assert.equal(obj.s16, 0x807); assert.equal(obj.u.uid, 0); assert.equal(obj.u.u32, 0x06050403); const b2 = Buffer.alloc(st.span); assert.equal(st.encode(obj, b2), st.span); assert.equal(b2.compare(b), 0); un.addVariant(0, lo.u32(), 'v0'); obj = st.decode(b); assert.equal(obj.vid, 0); assert.equal(obj.u16, 0x201); assert.equal(obj.s16, 0x807); assert.equal(obj.u.v0, 0x06050403); const flo = lo.f32('f32'); un.addVariant(1, flo, 'vf'); const fb = Buffer.from('01234500805a429876', 'hex'); const fobj = st.decode(fb); assert.equal(fobj.vid, 1); assert.equal(fobj.u16, 0x4523); assert.equal(fobj.s16, 0x7698); assert.equal(fobj.u.vf, 54.625); }); test('from src', function() { const un = new lo.Union(lo.u8('v'), lo.u32('u32')); const v0 = un.addVariant(0, 'nul'); const v1 = un.addVariant(1, lo.f32(), 'f32'); const v2 = un.addVariant(2, lo.seq(lo.u8(), 4), 'u8.4'); const v3 = un.addVariant(3, lo.cstr(), 'str'); const b = Buffer.alloc(un.span); assert.equal(un.span, 5); // Unregistered variant with default content let src = {v: 5, u32: 0x12345678}; let vlo = un.getSourceVariant(src); assert.strictEqual(vlo, undefined); assert.equal(un.encode(src, b), un.span); assert.equal(Buffer.from('0578563412', 'hex').compare(b), 0); // Unregistered variant without default content src = {v: 5}; assert.throws(() => un.getSourceVariant(src), Error); // Registered variant with default content src = {v: 1, u32: 0x12345678}; assert.strictEqual(un.getSourceVariant(src), undefined); // Registered variant with incompatible content src = {v: 2, f32: 26.5}; assert.throws(() => un.getSourceVariant(src), Error); // Registered variant with no content src = {v: 0}; vlo = un.getSourceVariant(src); assert.strictEqual(vlo, v0); b.fill(255); assert.equal(vlo.encode(src, b), 1); assert.strictEqual(un.getSpan(b), 5); assert.equal(Buffer.from('00ffffffff', 'hex').compare(b), 0); // Registered variant with compatible content (ignore discriminator) src = {v: 1, f32: 26.5}; assert.strictEqual(un.getSourceVariant(src), v1); // Inferred variant from content src = {f32: 26.5}; vlo = un.getSourceVariant(src); assert.strictEqual(vlo, v1); assert.equal(vlo.encode(src, b), un.span); assert.equal(Buffer.from('010000d441', 'hex').compare(b), 0); assert.equal(un.encode(src, b), un.span); assert.equal(Buffer.from('010000d441', 'hex').compare(b), 0); src = {'u8.4': [1, 2, 3, 4]}; vlo = un.getSourceVariant(src); assert.strictEqual(vlo, v2); assert.equal(vlo.encode(src, b), un.span); assert.equal(Buffer.from('0201020304', 'hex').compare(b), 0); assert.equal(un.encode(src, b), un.span); assert.equal(Buffer.from('0201020304', 'hex').compare(b), 0); assert.throws(() => un.getSourceVariant({other: 3}), Error); src = {str: 'hi'}; vlo = un.getSourceVariant(src); assert.strictEqual(vlo, v3); b.fill(0xFF); assert.equal(vlo.encode(src, b), 1 + 2 + 1); assert.equal(Buffer.from('03686900FF', 'hex').compare(b.slice(0, 5 + 2)), 0); assert(0 > vlo.layout.span); assert.equal(vlo.span, un.span); assert.equal(vlo.layout.getSpan(b, 1), 3); assert.equal(vlo.getSpan(b), un.span); src = {v: 6}; assert.throws(() => un.getSourceVariant(src), Error); }); test('customize src', function() { const un = lo.union(lo.u8('v'), lo.u32('u32')); let csrc; un.configGetSourceVariant(function(src) { csrc = src; // eslint-disable-next-line no-invalid-this return this.defaultGetSourceVariant(src); }); const src = {v: 3, u32: 29}; const vlo = un.getSourceVariant(src); assert.strictEqual(src, csrc); assert.strictEqual(vlo, undefined); }); test('variable span', function() { const un = lo.union(lo.u8('v')); const v0 = un.addVariant(0, 'nul'); const v1 = un.addVariant(1, lo.u32(), 'u32'); const v2 = un.addVariant(2, lo.f64(), 'f64'); const v3 = un.addVariant(3, lo.cstr(), 'str'); const v255 = un.addVariant(255); // unnamed contentless const b = Buffer.alloc(16); assert(0 > un.span); b.fill(0xa5); assert.throws(() => un.decode(b), Error); let obj = {v: v255.variant}; assert.equal(un.encode(obj, b), 1 + 0); assert.equal(Buffer.from('ffa5a5', 'hex') .compare(b.slice(0, 1 + 2)), 0); assert.strictEqual(v255.layout, null); assert.deepEqual(un.decode(b), obj); assert.equal(v0.getSpan(b), 1); assert.equal(un.getSpan(b), 1); obj = {nul: true}; b.fill(0xff); assert.equal(un.encode(obj, b), 1 + 0); assert.equal(Buffer.from('00ffff', 'hex') .compare(b.slice(0, 1 + 2)), 0); assert.strictEqual(v0.layout, null); assert.deepEqual(un.decode(b), obj); assert.equal(v0.getSpan(b), 1); assert.equal(un.getSpan(b), 1); b.fill(0xFF); obj = {u32: 0x12345678}; assert.equal(un.encode(obj, b), 1 + 4); assert.equal(v1.getSpan(b), 5); assert.equal(un.getSpan(b), 5); assert.equal(Buffer.from('0178563412ffff', 'hex') .compare(b.slice(0, 5 + 2)), 0); assert.deepEqual(un.decode(b), obj); b.fill(0xFF); obj = {f64: 1234.5}; assert.equal(un.encode(obj, b), 1 + 8); assert.equal(v2.getSpan(b), 9); assert.equal(un.getSpan(b), 9); assert.equal(Buffer.from('0200000000004a9340ffff', 'hex') .compare(b.slice(0, 9 + 2)), 0); assert.deepEqual(un.decode(b), obj); b.fill(0xFF); obj = {str: 'hi!'}; assert.equal(un.encode(obj, b), 1 + 3 + 1); assert.equal(v3.getSpan(b), 5); assert.equal(un.getSpan(b), 5); assert.equal(Buffer.from('0368692100ffff', 'hex') .compare(b.slice(0, 5 + 2)), 0); assert.deepEqual(un.decode(b), obj); b[0] = 5; assert.throws(() => un.getSpan(b), Error); b.fill(0xa5); assert.equal(un.encode(obj, b, 1), 1 + 3 + 1); assert.equal(v3.getSpan(b, 1), 5); assert.equal(un.getSpan(b, 1), 5); assert.equal(Buffer.from('a50368692100a5', 'hex') .compare(b.slice(0, 5 + 2)), 0); assert.deepEqual(un.decode(b, 1), obj); }); test('variable-external', function() { const dlo = lo.u8('v'); const ud = lo.unionLayoutDiscriminator(lo.offset(dlo, -1)); const un = lo.union(ud, null, 'u'); assert(0 > un.span); assert(!un.usesPrefixDiscriminator); const st = lo.struct([dlo, un], 'st'); const v0 = un.addVariant(0, 'nul'); const v1 = un.addVariant(1, lo.cstr(), 's'); const v2 = un.addVariant(2); let obj = {v: v1.variant, u: {s: 'hi'}}; const b = Buffer.alloc(6); b.fill(0xa5); st.encode(obj, b, 1); assert.equal(Buffer.from('a501686900a5', 'hex').compare(b), 0); assert.deepEqual(st.decode(b, 1), obj); obj = {v: v0.variant}; b.fill(0x5a); st.encode(obj, b, 1); assert.equal(Buffer.from('5a005a5a5a5a', 'hex').compare(b), 0); assert.deepEqual(st.decode(b, 1), Object.assign({u: {nul: true}}, obj)); obj = {v: v2.variant}; b.fill(0x5a); st.encode(obj, b, 1); assert.equal(Buffer.from('5a025a5a5a5a', 'hex').compare(b), 0); assert.deepEqual(st.decode(b, 1), Object.assign({u: {}}, obj)); }); }); test('fromArray', function() { assert.strictEqual(lo.u8().fromArray([1]), undefined); const st = new lo.Structure([lo.u8('a'), lo.u8('b'), lo.u16('c')]); assert.deepEqual(st.fromArray([1, 2, 3]), {a: 1, b: 2, c: 3}); assert.deepEqual(st.fromArray([1, 2]), {a: 1, b: 2}); const un = new lo.Union(lo.u8('v'), lo.u32('c')); assert.strictEqual(un.fromArray([1, 2, 3]), undefined); un.addVariant(0, 'v0'); const v1 = un.addVariant(1, st, 'v1'); un.addVariant(2, lo.f32(), 'v2'); assert(v1 instanceof lo.VariantLayout); assert.deepEqual(un.getVariant(0).fromArray([1, 2, 3]), undefined); assert.deepEqual(un.getVariant(1).fromArray([1, 2, 3]), {a: 1, b: 2, c: 3}); assert.strictEqual(un.getVariant(2).fromArray([1, 2, 3]), undefined); }); suite('BitStructure', function() { test('invalid ctor', function() { assert.throws(() => new lo.BitStructure(), TypeError); assert.throws(() => new lo.BitStructure(lo.f32()), TypeError); assert.throws(() => new lo.BitStructure(lo.s32()), TypeError); assert.throws(() => new lo.BitStructure(lo.u40()), Error); const bs = new lo.BitStructure(lo.u32()); assert.throws(() => new lo.BitField(lo.u32(), 8), TypeError); assert.throws(() => new lo.BitField(bs, 'hi'), TypeError); assert.throws(() => new lo.BitField(bs, 0), TypeError); assert.throws(() => new lo.BitField(bs, 40), Error); }); suite('ctor argument processing', function() { it('should infer property when passed string', function() { const bs = new lo.BitStructure(lo.u8(), 'flags'); assert.strictEqual(bs.msb, false); assert.strictEqual(bs.property, 'flags'); }); it('should respect msb without property', function() { const bs = new lo.BitStructure(lo.u8(), true); assert.strictEqual(bs.msb, true); assert.strictEqual(bs.property, undefined); }); it('should accept msb with property', function() { const bs = new lo.BitStructure(lo.u8(), 'flags', 'flags'); assert.strictEqual(bs.msb, true); assert.strictEqual(bs.property, 'flags'); }); }); // ctor argument processing test('invalid add', function() { assert.throws(() => { const bs = lo.bits(lo.u32()); bs.addField(30); bs.addField(3); }, Error); assert.throws(() => { const bs = lo.bits(lo.u8()); bs.addField(2); bs.addField(7); }, Error); assert.throws(() => { const bs = lo.bits(lo.u8()); bs.addField(0); }, Error); assert.throws(() => { const bs = lo.bits(lo.u8()); bs.addField(6); bs.addField(-2); }, Error); }); test('size', function() { const bs = new lo.BitStructure(lo.u16()); const bf10 = bs.addField(10, 'ten'); const bf6 = bs.addField(6, 'six'); let b = Buffer.alloc(bs.span); assert.equal((1 << 10) - 1, 1023); assert.equal((1 << 6) - 1, 63); const obj = bs.decode(Buffer.from('ffff', 'hex')); assert.equal(obj.ten, (1 << 10) - 1); assert.equal(obj.six, (1 << 6) - 1); assert.equal(bs.encode(obj, b), 2); assert.equal(Buffer.from('ffff', 'hex').compare(b), 0); b.fill(0); assert.equal(Buffer.from('0000', 'hex').compare(b), 0); bf10.encode((1 << 10) - 1); bf6.encode((1 << 6) - 1); assert.equal(bs._packedGetValue(), 0xFFFF); assert.throws(() => bf6.encode('hi', b), Error); assert.throws(() => bf6.encode(1 << 6, b), Error); b = Buffer.alloc(2 + bs.span); b.fill(0xa5); bs.encode(obj, b, 1); assert.equal(Buffer.from('a5ffffa5', 'hex').compare(b), 0); assert.deepEqual(bs.decode(b, 1), obj); }); test('basic LSB', function() { const pbl = lo.u32(); const bs = new lo.BitStructure(pbl); assert(bs instanceof lo.Layout); assert.strictEqual(bs.word, pbl); assert(!bs.msb); assert(bs.fields instanceof Array); assert.equal(bs.fields.length, 0); const bf1 = bs.addField(1, 'a'); const bf2 = bs.addField(2, 'b'); assert.equal(bs.fields.length, 2); assert(bf1 instanceof lo.BitField); assert(!(bf1 instanceof lo.Layout)); assert.strictEqual(bf1.container, bs); assert.equal(bf1.bits, 1); assert.equal(bf1.start, 0); assert.equal(bf1.valueMask, 0x01); assert.equal(bf1.wordMask, 0x01); assert(bf2 instanceof lo.BitField); assert(!(bf2 instanceof lo.Layout)); assert.strictEqual(bf2.container, bs); assert.equal(bf2.bits, 2); assert.equal(bf2.start, 1); assert.equal(bf2.valueMask, 0x03); assert.equal(bf2.wordMask, 0x06); assert.throws(() => bs.addField(30)); bs.addField(29, 'x'); const bf3 = bs.fields[2]; assert.equal(bf3.bits, 29); assert.equal(bf3.start, 3); assert.equal(bf3.wordMask, 0xFFFFFFF8); }); test('basic MSB', function() { const pbl = lo.u32(); const bs = new lo.BitStructure(pbl, true); assert(bs instanceof lo.Layout); assert.strictEqual(bs.word, pbl); assert(bs.msb); assert(bs.fields instanceof Array); assert.equal(bs.fields.length, 0); const bf1 = bs.addField(1, 'a'); const bf2 = bs.addField(2, 'b'); assert.equal(bs.fields.length, 2); assert(bf1 instanceof lo.BitField); assert(!(bf1 instanceof lo.Layout)); assert.strictEqual(bf1.container, bs); assert.equal(bf1.property, 'a'); assert.equal(bf1.bits, 1); assert.equal(bf1.start, 31); assert.equal(bf1.valueMask, 0x01); assert.equal(bf1.wordMask, 0x80000000); assert(bf2 instanceof lo.BitField); assert(!(bf2 instanceof lo.Layout)); assert.strictEqual(bf2.container, bs); assert.equal(bf2.property, 'b'); assert.equal(bf2.bits, 2); assert.equal(bf2.start, 29); assert.equal(bf2.valueMask, 0x3); assert.equal(bf2.wordMask, 0x60000000); assert.throws(() => bs.addField(30)); bs.addField(29, 'x'); const bf3 = bs.fields[2]; assert.equal(bf3.bits, 29); assert.equal(bf3.start, 0); assert.equal(bf3.wordMask, 0x1FFFFFFF); }); test('lsb 32-bit field', function() { const bs = new lo.BitStructure(lo.u32()); const bf = bs.addField(32, 'x'); assert.equal(bf.bits, 32); assert.equal(bf.start, 0); assert.equal(bf.valueMask, 0xFFFFFFFF); assert.equal(bf.wordMask, 0xFFFFFFFF); }); test('msb 32-bit field', function() { const bs = new lo.BitStructure(lo.u32(), true); const bf = bs.addField(32, 'x'); assert.equal(bf.bits, 32); assert.equal(bf.start, 0); assert.equal(bf.valueMask, 0xFFFFFFFF); assert.equal(bf.wordMask, 0xFFFFFFFF); }); test('lsb coding', function() { const bs = new lo.BitStructure(lo.u32()); const b = Buffer.alloc(bs.span); bs.addField(1, 'a1'); bs.addField(4, 'b4'); bs.addField(11, 'c11'); bs.addField(16, 'd16'); b.fill(0); assert.deepEqual(bs.decode(b), {a1: 0, b4: 0, c11: 0, d16: 0}); b.fill(0xFF); assert.deepEqual(bs.decode(b), {a1: 1, b4: 0x0F, c11: 0x7FF, d16: 0xFFFF}); assert.equal(bs.encode({a1: 0, b4: 9, c11: 0x4F1, d16: 0x8a51}, b), 4); assert.deepEqual(bs.decode(b), {a1: 0, b4: 9, c11: 0x4F1, d16: 0x8a51}); assert.equal(Buffer.from('329e518a', 'hex').compare(b), 0); }); test('msb coding', function() { const bs = new lo.BitStructure(lo.u32(), true); const b = Buffer.alloc(bs.span); bs.addField(1, 'a1'); bs.addField(4, 'b4'); bs.addField(11, 'c11'); bs.addField(16, 'd16'); b.fill(0); assert.deepEqual(bs.decode(b), {a1: 0, b4: 0, c11: 0, d16: 0}); b.fill(0xFF); assert.deepEqual(bs.decode(b), {a1: 1, b4: 0x0F, c11: 0x7FF, d16: 0xFFFF}); assert.equal(bs.encode({a1: 0, b4: 9, c11: 0x4F1, d16: 0x8a51}, b), 4); assert.deepEqual(bs.decode(b), {a1: 0, b4: 9, c11: 0x4F1, d16: 0x8a51}); assert.equal(Buffer.from('518af14c', 'hex').compare(b), 0); }); test('fieldFor', function() { const d = new lo.BitStructure(lo.u32(), true); const b = d.addBoolean('b'); d.addField(4, 'b4'); const c11 = d.addField(11, 'c11'); d.addField(16, 'd16'); assert.throws(() => d.fieldFor(), err => ('property must be string' === err.message)); assert.strictEqual(d.fieldFor('b'), b); assert.strictEqual(d.fieldFor('c11'), c11); assert.strictEqual(d.fieldFor('other'), undefined); }); test('gap coding', function() { const lsb = new lo.BitStructure(lo.u24()); const msb = new lo.BitStructure(lo.u24(), true); const b = Buffer.alloc(lsb.span); lsb.addField(7, 'a5'); lsb.addField(8); lsb.addField(9, 'b6'); msb.addField(7, 'a5'); msb.addField(8); msb.addField(9, 'b6'); b.fill(0xA5); const lb = lsb.decode(b); const mb = msb.decode(b); assert.deepEqual(lb, {a5: 0x25, b6: 0x14b}); assert.deepEqual(mb, {a5: 0x52, b6: 0x1a5}); b.fill(0x69); assert.equal(lsb.encode(lb, b), 3); assert.equal(Buffer.from('25e9a5', 'hex').compare(b), 0); b.fill(0x69); assert.equal(msb.encode(mb, b), 3); assert.equal(Buffer.from('a569a5', 'hex').compare(b), 0); }); test('boolean', function() { const bs = lo.bits(lo.u8()); bs.addField(1, 'v'); bs.addBoolean('b'); const b = Buffer.alloc(bs.span); b[0] = 0x3; const obj = bs.decode(b); assert.strictEqual(1, obj.v); assert.notStrictEqual(1, obj.b); assert.strictEqual(true, obj.b); assert.notStrictEqual(true, obj.v); bs.encode({v: 1, b: 1}, b); assert.equal(b[0], 3); bs.encode({v: 1, b: true}, b); assert.equal(b[0], 3); bs.encode({v: 0, b: 0}, b); assert.equal(b[0], 0); bs.encode({v: 0, b: false}, b); assert.equal(b[0], 0); bs.encode({}, b); assert.equal(b[0], 0); assert.throws(() => bs.encode({v: false}, b), err => checkError(err, TypeError, /BitField.encode\[v\] value must be integer/)); assert.throws(() => bs.encode({v: 1.2}, b), err => checkError(err, TypeError, /BitField.encode\[v\] value must be integer/)); assert.throws(() => bs.encode({b: 1.2}, b), err => checkError(err, TypeError, /BitField.encode\[b\] value must be integer/)); }); }); suite('Blob', function() { test('invalid ctor', function() { assert.throws(() => new lo.Blob(), TypeError); assert.throws(() => new lo.Blob(lo.u8()), TypeError); assert.throws(() => new lo.Blob(lo.offset(lo.f32())), TypeError); }); test('ctor', function() { const bl = new lo.Blob(3, 'bl'); assert(bl instanceof lo.Blob); assert(bl instanceof lo.Layout); assert.equal(bl.span, 3); assert.equal(bl.property, 'bl'); }); test('basics', function() { const bl = new lo.Blob(3, 'bl'); const b = Buffer.from('0102030405', 'hex'); let bv = bl.decode(b); assert(bv instanceof Buffer); assert.equal(bv.length, bl.span); assert.equal(Buffer.from('010203', 'hex').compare(bv), 0); bv = bl.decode(b, 2); assert.equal(bl.getSpan(b), bl.span); assert.equal(Buffer.from('030405', 'hex').compare(bv), 0); assert.equal(bl.encode(Buffer.from('112233', 'hex'), b, 1), 3); assert.equal(Buffer.from('0111223305', 'hex').compare(b), 0); assert.throws(() => bl.encode('ABC', b), Error); assert.throws(() => bl.encode(Buffer.from('0102', 'hex'), b), Error); }); test('const length', function() { const llo = lo.u8('l'); const blo = lo.blob(lo.offset(llo, -1), 'b'); const st = lo.struct([llo, blo]); const b = Buffer.alloc(10); assert(0 > st.span); assert.strictEqual(blo.length.layout, llo); assert.equal(st.encode({b: Buffer.from('03040506', 'hex')}, b), llo.span + 4); const span = st.getSpan(b); assert.equal(span, 5); assert.equal(Buffer.from('0403040506', 'hex').compare(b.slice(0, span)), 0); const obj = st.decode(b); assert.equal(obj.l, 4); assert.equal(obj.b.toString('hex'), '03040506'); assert.throws(() => { st.encode({b: Buffer.alloc(b.length)}, b, 1); }, RangeError); }); test('greedy', function() { const blo = lo.blob(lo.greedy(), 'b'); const b = Buffer.from('ABCDx'); assert.equal(Buffer.from('ABCDx').compare(blo.decode(b)), 0); assert.equal(Buffer.from('Dx').compare(blo.decode(b, 3)), 0); b.fill(0); assert.equal(blo.encode(Buffer.from('0203', 'hex'), b, 2), 2); assert.equal(Buffer.from('0000020300', 'hex').compare(b), 0); }); }); suite('issue#8', function() { test('named', function() { const ver = lo.u8('ver'); const hdr = new lo.Structure([lo.u8('id'), lo.u8('ver')], 'hdr'); const pld = new lo.Union(lo.offset(ver, -ver.span), new lo.Blob(8, 'blob'), 'u'); const pkt = new lo.Structure([hdr, pld], 's'); const expectedBlob = Buffer.from('1011121314151617', 'hex'); const b = Buffer.from('01021011121314151617', 'hex'); assert.deepEqual(hdr.decode(b), {id: 1, ver: 2}); const du = pld.decode(b, 2); assert.equal(du.ver, 2); assert.equal(expectedBlob.compare(du.blob), 0); let dp = pkt.decode(b); assert.deepEqual(dp.hdr, {id: 1, ver: 2}); assert.equal(dp.u.ver, 2); assert.equal(expectedBlob.compare(dp.u.blob), 0); pld.addVariant(2, new lo.Sequence(lo.u32(), 2, 'u32'), 'v3'); assert.deepEqual(pld.decode(b, 2), {v3: [0x13121110, 0x17161514]}); dp = pkt.decode(b); assert.deepEqual(dp, {hdr: {id: 1, ver: 2}, u: {v3: [0x13121110, 0x17161514]}}); }); test('anon', function() { const ver = lo.u8('ver'); const hdr = new lo.Structure([lo.u8('id'), lo.u8('ver')]); const pld = new lo.Union(lo.offset(ver, -ver.span), new lo.Blob(8, 'blob')); const expectedBlob = Buffer.from('1011121314151617', 'hex'); const b = Buffer.from('01021011121314151617', 'hex'); assert.deepEqual(hdr.decode(b), {id: 1, ver: 2}); const du = pld.decode(b, 2); assert.equal(du.ver, 2); assert.equal(expectedBlob.compare(du.blob), 0); /* This is what I want, but can't get. */ // const dp = pkt.decode(b); // assert.equal(dp.id, 1); // assert.equal(dp.ver, 2); // assert.equal(expectedBlob.compare(dp.blob), 0); pld.addVariant(2, new lo.Sequence(lo.u32(), 2, 'u32'), 'v3'); assert.deepEqual(pld.decode(b, 2), {v3: [0x13121110, 0x17161514]}); /* Ditto on want */ // assert.deepEqual(dp, {id:1, ver:2, u32: [0x13121110, 0x17161514]}); }); }); suite('factories', function() { test('anon', function() { const ver = lo.u8('ver'); const hdr = lo.struct([lo.u8('id'), lo.u8('ver')]); const pld = lo.union(lo.offset(ver, -ver.span), lo.blob(8, 'blob')); assert(hdr instanceof lo.Structure); assert(pld instanceof lo.Union); assert(pld.defaultLayout instanceof lo.Blob); assert.equal(pld.defaultLayout.property, 'blob'); }); }); suite('CString', function() { test('ctor', function() { const cst = lo.cstr(); assert(0 > cst.span); }); test('#getSpan', function() { const cst = new lo.CString(); assert.throws(() => cst.getSpan(), TypeError); assert.equal(cst.getSpan(Buffer.from('00', 'hex')), 1); assert.equal(cst.getSpan(Buffer.from('4100', 'hex')), 2); assert.equal(cst.getSpan(Buffer.from('4100', 'hex'), 1), 1); assert.equal(cst.getSpan(Buffer.from('4142', 'hex')), 3); }); test('#decode', function() { const cst = new lo.CString(); assert.equal(cst.decode(Buffer.from('00', 'hex')), ''); assert.equal(cst.decode(Buffer.from('4100', 'hex')), 'A'); assert.equal(cst.decode(Buffer.from('4100', 'hex'), 1), ''); assert.equal(cst.decode(Buffer.from('4142', 'hex')), 'AB'); }); test('#encode', function() { const cst = new lo.CString(); const b = Buffer.alloc(4); b.fill(0xFF); assert.equal(Buffer.from('A', 'utf8').length, 1); assert.equal(cst.encode('', b), 1); assert.equal(Buffer.from('00ffffff', 'hex').compare(b), 0); assert.equal(cst.encode('A', b), 1 + 1); assert.equal(Buffer.from('4100ffff', 'hex').compare(b), 0); assert.equal(cst.encode('B', b, 1), 1 + 1); assert.equal(Buffer.from('414200ff', 'hex').compare(b), 0); assert.equal(cst.encode(5, b), 1 + 1); assert.equal(Buffer.from('350000ff', 'hex').compare(b), 0); assert.throws(() => cst.encode('too long', b), RangeError); }); test('in struct', function() { const st = lo.struct([lo.cstr('k'), lo.cstr('v')]); const b = Buffer.from('6100323300', 'hex'); assert.throws(() => st.getSpan(), RangeError); assert.equal(st.fields[0].getSpan(b), 2); assert.equal(st.fields[1].getSpan(b, 2), 3); assert.equal(st.getSpan(b), 5); assert.deepEqual(st.decode(b), {k: 'a', v: '23'}); b.fill(0xff); assert.equal(st.encode({k: 'a', v: 23}, b), (1 + 1) + (2 + 1)); }); test('in seq', function() { const seq = lo.seq(lo.cstr(), 3); const b = Buffer.from('61006263003500', 'hex'); assert.deepEqual(seq.decode(b), ['a', 'bc', '5']); assert.equal(seq.encode(['hi', 'u', 'c'], b), (1 + 1) + (2 + 1) + (1 + 1)); assert.equal(Buffer.from('68690075006300', 'hex').compare(b), 0); }); }); suite('UTF8', function() { test('ctor', function() { const cst = lo.utf8(); assert(0 > cst.span); assert.strictEqual(cst.maxSpan, -1); }); test('ctor with maxSpan', function() { const cst = lo.utf8(5); assert.strictEqual(cst.maxSpan, 5); }); test('ctor with invalid maxSpan', function() { assert.throws(() => new lo.UTF8(23.1), TypeError); }); test('#getSpan', function() { const cst = new lo.UTF8(); assert.throws(() => cst.getSpan(), TypeError); assert.equal(cst.getSpan(Buffer.from('00', 'hex')), 1); assert.equal(cst.getSpan(Buffer.from('4100', 'hex')), 2); assert.equal(cst.getSpan(Buffer.from('4100', 'hex'), 1), 1); assert.equal(cst.getSpan(Buffer.from('4142', 'hex')), 2); }); test('#decode', function() { const cst = new lo.UTF8(3); assert.equal(cst.decode(Buffer.from('00', 'hex')), '\x00'); assert.equal(cst.decode(Buffer.from('4100', 'hex')), 'A\x00'); assert.equal(cst.decode(Buffer.from('4100', 'hex'), 1), '\x00'); assert.equal(cst.decode(Buffer.from('4142', 'hex')), 'AB'); assert.throws(() => cst.decode(Buffer.from('four', 'utf8')), RangeError); }); test('#encode', function() { const cst = new lo.UTF8(); const b = Buffer.alloc(3); b.fill(0xFF); assert.equal(cst.encode('', b), 0); assert.equal(Buffer.from('ffffff', 'hex').compare(b), 0); assert.equal(cst.encode('A', b), 1); assert.equal(Buffer.from('41ffff', 'hex').compare(b), 0); assert.equal(cst.encode('B', b, 1), 1); assert.equal(Buffer.from('4142ff', 'hex').compare(b), 0); assert.equal(cst.encode(5, b), 1); assert.equal(Buffer.from('3542ff', 'hex').compare(b), 0); assert.equal(cst.encode('abc', b), 3); assert.equal(Buffer.from('616263', 'hex').compare(b), 0); assert.throws(() => cst.encode('four', b), RangeError); }); test('#encode with maxSpan', function() { const cst = new lo.UTF8(2); const b = Buffer.alloc(3); b.fill(0xFF); assert.throws(() => cst.encode('abc', b), RangeError); }); test('in struct', function() { const st = lo.struct([lo.utf8('k'), lo.utf8('v')]); const b = Buffer.from('6162323334', 'hex'); assert.throws(() => st.getSpan(), RangeError); assert.equal(st.fields[0].getSpan(b), b.length); assert.equal(st.fields[1].getSpan(b, 2), b.length - 2); assert.equal(st.getSpan(b), b.length); assert.deepEqual(st.decode(b), {k: 'ab234', v: ''}); }); test('in seq', function() { const seq = lo.seq(lo.utf8(), 3); const b = Buffer.from('4162633435', 'hex'); assert.deepEqual(seq.decode(b), ['Abc45', '', '']); b.fill(0xFF); assert.equal(seq.encode(['hi', 'u', 'c'], b), 2 + 1 + 1); assert.equal(Buffer.from('68697563ff', 'hex').compare(b), 0); }); }); suite('Constant', function() { test('ctor', function() { const c = new lo.Constant('value', 'p'); assert.equal(c.value, 'value'); assert.equal(c.property, 'p'); assert.equal(c.span, 0); }); test('basics', function() { const b = Buffer.from('', 'hex'); assert.strictEqual(lo.const(true).decode(b), true); assert.strictEqual(lo.const(undefined).decode(b), undefined); const obj = {a: 23}; assert.strictEqual(lo.const(obj).decode(b), obj); /* No return value to check, but this shouldn't throw an * exception (which it would if it tried to mutate the * zero-length buffer). */ assert.equal(lo.const(32).encode(b), 0); assert.equal(b.length, 0); }); }); suite('objectConstructor', function() { test('invalid ctor', function() { function Class() {} assert.throws(() => lo.bindConstructorLayout(4), TypeError); assert.throws(() => lo.bindConstructorLayout(Class), TypeError); assert.throws(() => lo.bindConstructorLayout(Class, 4), TypeError); const clo = lo.struct([lo.u8('u8')]); lo.bindConstructorLayout(Class, clo); assert(Class.hasOwnProperty('layout_')); assert(clo.hasOwnProperty('boundConstructor_')); assert.throws(() => lo.bindConstructorLayout(Class, clo), Error); function Class2() {} assert.throws(() => lo.bindConstructorLayout(Class2, clo), Error); }); test('struct', function() { function Sample(temp_dCel, humidity_ppt) { this.temp_dCel = temp_dCel; this.humidity_ppt = humidity_ppt; } const slo = lo.struct([lo.s32('temp_dCel'), lo.u32('humidity_ppt')], 'sample'); lo.bindConstructorLayout(Sample, slo); assert.strictEqual(Sample.layout_, slo); assert(slo.makeDestinationObject() instanceof Sample); assert(Sample.prototype.encode); assert(!Sample.prototype.propertyIsEnumerable('encode')); assert(Sample.decode); assert(!Sample.propertyIsEnumerable('decode')); /* Verify that synthesized encode/decode may be extended. */ let called; const synthesizedEncode = Sample.prototype.encode; assert('function' === typeof synthesizedEncode); Sample.prototype.encode = function(src, b, offset) { called = true; return synthesizedEncode.bind(this)(src, b, offset); }; const synthesizedDecode = Sample.decode; assert('function' === typeof synthesizedDecode); Sample.decode = function(b, offset) { called = true; return synthesizedDecode(b, offset); }; const p = new Sample(223, 672); assert(p instanceof Sample); assert.equal(p.temp_dCel, 223); assert.equal(p.humidity_ppt, 672); let po = Object.create(Sample.prototype); assert(po instanceof Sample); const b = Buffer.alloc(8); assert(!called); p.encode(b); assert(called); assert.equal(Buffer.from('df000000a0020000', 'hex').compare(b), 0); po = Sample.layout_.decode(b); assert(po instanceof Sample); assert.deepEqual(po, p); called = false; po = Sample.decode(b); assert(called); assert(po instanceof Sample); assert.deepEqual(po, p); }); test('bits', function() { function Header() {} Header.prototype.power = function() { return ['off', 'lo', 'med', 'hi'][this.pwr]; }; lo.bindConstructorLayout(Header, lo.bits(lo.u8())); Header.layout_.addField(2, 'ver'); Header.layout_.addField(2, 'pwr'); const b = Buffer.from('07', 'hex'); const hdr = Header.decode(b); assert(hdr instanceof Header); assert.equal(hdr.ver, 3); assert.equal(hdr.pwr, 1); assert.equal(hdr.power(), 'lo'); const nb = Buffer.alloc(1); nb.fill(0); assert.equal(1, hdr.encode(nb)); assert.equal(b.compare(nb), 0); }); test('union', function() { function Union() {} lo.bindConstructorLayout(Union, lo.union(lo.u8('var'), lo.blob(8, 'unk'))); function VFloat(v) { this.f32 = v; } util.inherits(VFloat, Union); lo.bindConstructorLayout(VFloat, Union.layout_.addVariant(1, lo.f32(), 'f32')); function VCStr(v) { this.text = v; } util.inherits(VCStr, Union); lo.bindConstructorLayout(VCStr, Union.layout_.addVariant(2, lo.cstr(), 'text')); function Struct(u32, u16, s16) { this.u32 = u32; this.u16 = u16; this.s16 = s16; } function VStruct(v) { this.struct = v; } util.inherits(VStruct, Union); const str = lo.struct([lo.u32('u32'), lo.u16('u16'), lo.s16('s16')]); lo.bindConstructorLayout(Struct, str); lo.bindConstructorLayout(VStruct, Union.layout_.addVariant(3, str, 'struct')); let b = Buffer.alloc(Union.layout_.span); b.fill(0); let u = Union.decode(b); assert(u instanceof Union); assert.equal(u.var, 0); b[0] = 1; u = Union.decode(b); assert(u instanceof VFloat); assert(u instanceof Union); assert.equal(u.f32, 0.0); b[0] = 2; b[1] = 65; b[2] = 66; u = Union.decode(b); assert(u instanceof VCStr); assert(u instanceof Union); assert.equal(u.text, 'AB'); b = Buffer.from('030403020122218281', 'hex'); u = Union.decode(b); assert(u instanceof VStruct); assert(u instanceof Union); assert(u.struct instanceof Struct); assert.deepEqual(u.struct, {u32: 0x01020304, u16: 0x2122, s16: -32382}); u.struct = new Struct(1, 2, -3); assert.equal(Union.layout_.span, Union.layout_.encode(u, b)); assert.equal(Buffer.from('03010000000200fdff', 'hex').compare(b), 0); }); }); });