meteora/node_modules/buffer-layout/test/LayoutTest.js

'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);
    });
  });
});