@meteora-ag/cp-amm-sdk 1.0.1-rc.35 → 1.0.1-rc.36

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

@@ -1,2162 +0,0 @@
-'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);
-    });
-  });
-});