passes: 710
failures: 0
duration: 0.47s

binary32 and binary64 in an env with no Uint8Array

pack pi as 3.14159265358979311ms ‣

global.Uint8Array = undefined;
assert.deepEqual(
  binaryTools.pack('d', 3.1415926535897931), 
  [0x18,0x2d,0x44,0x54,0xfb,0x21,0x09,0x40]);
global.Uint8Array = tmp;

unpack pi as 3.14159265358979310ms ‣

global.Uint8Array = undefined;
assert.equal(
  binaryTools.unpack(
    'd', [0x18,0x2d,0x44,0x54,0xfb,0x21,0x09,0x40])[0].toFixed(15), 
  '3.141592653589793');
global.Uint8Array = tmp;

pack pi as 3.14159274100ms ‣

global.Uint8Array = undefined;
assert.deepEqual(
  binaryTools.pack('f', 3.1415927410), 
  [0xdb,0x0F,0x49,0x40]);
global.Uint8Array = tmp;

unpack pi as 3.14159274100ms ‣

global.Uint8Array = undefined;
assert.equal(
  binaryTools.unpack('f', [0xdb,0x0F,0x49,0x40])[0].toFixed(10), 
  '3.1415927410');
global.Uint8Array = tmp;

interface

pack true uInt16 (1, 0) should raise a NaN error0ms ‣

assert.throws(
  function() {
    binaryTools.pack('H', true);
  },
  /index 0, true/);

pack false uInt16 (0, 0) should raise a NaN error0ms ‣

assert.throws(
  function() {
    binaryTools.pack('H', false);
  },
  /index 0, false/);

pack uInt16 (65535, 16)0ms ‣

assert.deepEqual(
  binaryTools.pack('H', 65535),
  [255,255]);

pack float32 (2.1474836, 16)0ms ‣

assert.deepEqual(
  binaryTools.pack('f', 2.1474836),
  [95,112,9,64]);

pack uInt8 (254)0ms ‣

assert.deepEqual(
  binaryTools.pack('B', 254),
  [254]);

pack uInt8 (255)0ms ‣

assert.deepEqual(
  binaryTools.pack('B', 255),
  [255]);

pack int8 (-1)0ms ‣

assert.deepEqual(
  binaryTools.pack('b', -1),
  [255]);

pack int8 (-2)0ms ‣

assert.deepEqual(
  binaryTools.pack('b', -2),
  [254]);

throws a TypeError if packString value is a number0ms ‣

var testFunc = function() {
  binaryTools.packString(1);
};
assert.throws(testFunc, TypeError);

unpack uInt160ms ‣

assert.deepEqual(
  binaryTools.unpack('H', [255, 255])[0],
  65535);

unpack float160ms ‣

assert.equal(
  binaryTools.unpack('e', [85, 53])[0].toFixed(5),
  0.33325);

unpack uInt160ms ‣

assert.equal(
  binaryTools.unpack('H', [255,255])[0],
  65535);

packArray uInt160ms ‣

assert.deepEqual(
  binaryTools.write('H', [65535, 0]),
  [255, 255, 0, 0]);

packArray int320ms ‣

assert.deepEqual(
  binaryTools.write('l', [-2147483648, 2147483647]),
  [0,0,0,128,255,255,255,127]);

packArray float320ms ‣

assert.deepEqual(binaryTools.write('f', [-1, 1]),
  [0,0,128,191,0,0,128,63]);

should ignore repeat count numbers on write()0ms ‣

assert.deepEqual(binaryTools.write('6f', [-1, 1]),
  [0,0,128,191,0,0,128,63]);

should ignore repeat count numbers on write()0ms ‣

assert.deepEqual(binaryTools.write('1f', [-1, 1]),
  [0,0,128,191,0,0,128,63]);

read uInt160ms ‣

assert.deepEqual(
  binaryTools.read('H', [255, 255, 0, 0]),
  [65535, 0]);

should ignore repeat count numbers on read()0ms ‣

assert.deepEqual(
  binaryTools.read('1H', [255, 255, 0, 0]),
  [65535, 0]);

should ignore repeat count numbers on read()0ms ‣

assert.deepEqual(
  binaryTools.read('10H', [255, 255, 0, 0]),
  [65535, 0]);

read float640ms ‣

assert.deepEqual(
  binaryTools.read('d', [0,0,0,0,0,0,240,63]),
  [1]);

read behaviour tests

Ignores extra bytes for 32-bit values0ms ‣

assert.deepEqual(
  binaryTools.read('l', [0,0,0,128, 255,255,255,127,255,128]),
  [-2147483648,2147483647]);

Ignores extra bytes for 24-bit values0ms ‣

assert.deepEqual(
  binaryTools.read('T', [0,0,0,255,255,255,255]),
  [0,16777215]);

Errors

throws errors with correct index when packing0ms ‣

var testFunc = function() {
  binaryTools.write('H', [0, '1']);
};
assert.throws(testFunc, /index 1/);

thows error if packing something other than Number, Boolean or null0ms ‣

var testFunc = function() {
  binaryTools.pack('H', {some: 'thing'});
};
assert.throws(testFunc, Error);

undefined value0ms ‣

var testFunc = function() {
  binaryTools.pack('B', undefined);
};
assert.throws(testFunc, /index 0/);

null value0ms ‣

var testFunc = function() {
  binaryTools.pack('B', null);
};
assert.throws(testFunc, /index 0/);

string value0ms ‣

var testFunc = function() {
  binaryTools.pack('B', 'c');
};
assert.throws(testFunc, /index 0/);

undefined value, index 10ms ‣

var testFunc = function() {
  binaryTools.write('B', [0, undefined]);
};
assert.throws(testFunc, /index 1/);

Infinity value, index 10ms ‣

var testFunc = function() {
  binaryTools.write('B', [0, Infinity]);
};
assert.throws(testFunc, /index 1, Infinity/);

-Infinity value, index 10ms ‣

var testFunc = function() {
  binaryTools.write('B', [0, -Infinity]);
};
assert.throws(testFunc, /index 1, -Infinity/);

NaN value, index 10ms ‣

var testFunc = function() {
  binaryTools.write('B', [0, NaN]);
};
assert.throws(testFunc, /index 1, NaN/);

char, index 10ms ‣

var testFunc = function() {
  binaryTools.write('B', [0, 'a']);
};
assert.throws(testFunc, /index 1/);

thows error if packing something other than Number or Boolean (float)1ms ‣

var testFunc = function() {
  binaryTools.pack('f', {some: 'thing'});
};
assert.throws(testFunc, Error);

undefined value0ms ‣

var testFunc = function() {
  binaryTools.pack('f', undefined);
};
assert.throws(testFunc, /index 0/);

null value0ms ‣

var testFunc = function() {
  binaryTools.pack('f', null);
};
assert.throws(testFunc, /index 0/);

string value0ms ‣

var testFunc = function() {
  binaryTools.pack('f', 'c');
};
assert.throws(testFunc, /index 0/);

undefined value, index 10ms ‣

var testFunc = function() {
  binaryTools.write('f', [0, undefined]);
};
assert.throws(testFunc, /index 1/);

char, index 10ms ‣

var testFunc = function() {
  binaryTools.write('f', [0, 'a']);
};
assert.throws(testFunc, /index 1/);

Bad buffer length on unpack, missing a byte, safe mode0ms ‣

var testFunc = function() {
  binaryTools.unpack('H', [1], 0, true);
};
assert.throws(testFunc, /Bad buffer length/);

Bad buffer length on unpack, zero bytes, safe mode0ms ‣

var testFunc = function() {
  binaryTools.unpack('H', [], 0, true);
};
assert.throws(testFunc, /Bad buffer length/);

8-bit overflow, positive0ms ‣

var testFunc = function() {
  binaryTools.pack('B', 256);
};
assert.throws(testFunc, /index 0, 256/);

8-bit overflow, negative0ms ‣

var testFunc = function() {
  binaryTools.pack('B', -1);
};
assert.throws(testFunc, /index 0, -1/);

8-bit overflow, negative, index 20ms ‣

var testFunc = function() {
  binaryTools.write('B', [1, -1]);
};
assert.throws(testFunc, /index 1, -1/);

type is a empty array1ms ‣

var testFunc = function() {
  console.log(binaryTools.pack([], 2));
};
assert.throws(testFunc, /Unsupported type/);

type is a empty object0ms ‣

var testFunc = function() {
  console.log(binaryTools.pack({}, 2));
};
assert.throws(testFunc, /Unsupported type/);

pack type is a number0ms ‣

var testFunc = function() {
  console.log(binaryTools.pack(1, 2));
};
assert.throws(testFunc, /Unsupported type/);

unpack type is a number0ms ‣

var testFunc = function() {
  console.log(binaryTools.unpack(1, [2]));
};
assert.throws(testFunc, /Unsupported type/);

write type is a number0ms ‣

var testFunc = function() {
  console.log(binaryTools.write(1, [2]));
};
assert.throws(testFunc, /Unsupported type/);

read type is a number0ms ‣

var testFunc = function() {
  console.log(binaryTools.read(1, [2]));
};
assert.throws(testFunc, /Unsupported type/);

writeTo type is a number0ms ‣

var testFunc = function() {
  var buffer = new Array(2);
  console.log(binaryTools.writeTo(1, [2], buffer));
};
assert.throws(testFunc, /Unsupported type/);

readTo type is a number1ms ‣

var testFunc = function() {
  var buffer = new Array(2);
  console.log(binaryTools.readTo(1, [2], buffer));
};
assert.throws(testFunc, /Unsupported type/);

-1bit)0ms ‣

var testFunc = function() {
  binaryTools.setType('Z', -1);
  binaryTools.pack('Z', 2);
};
assert.throws(testFunc, /Unsupported type/);

writeTo: LE

Check the packed 16-bit values0ms ‣

assert.deepEqual(file, [255, 255, 253, 2, 0, 0, 0, 0]);

Check the index0ms ‣
```
assert.equal(index, 4);
```

writeTo: LE (write to the middle of array)
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [0, 0, 0, 0, 255, 255, 253, 2]);
```
- Check the index0ms ‣
```
assert.equal(index, 8);
```

writeTo: BE

Check the packed 16-bit values0ms ‣

assert.deepEqual(file, [255, 255, 2, 253, 0, 0, 0, 0]);

Check the index1ms ‣
```
assert.equal(index, 4);
```

writeTo: BE (write to the middle of array)
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [0, 0, 0, 0, 255, 255, 2, 253]);
```
- Check the index0ms ‣
```
assert.equal(index, 8);
```
pack to typed array: LE
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [255, 255, 253, 2]);
```
- Check the index0ms ‣
```
assert.equal(index, 4);
```
pack to typed array: LE (write to the middle of array)
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [1, 7, 253, 2]);
```
- Check the index0ms ‣
```
assert.equal(index, 4);
```
pack to typed array: BE
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [255, 255, 2, 253]);
```
- Check the index0ms ‣
```
assert.equal(index, 4);
```
pack to typed array: BE (write to the middle of array)
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [1, 7, 2, 253]);
```
- Check the index0ms ‣
```
assert.equal(index, 4);
```
pack to typed array: float32 LE
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [95,112,9,64,  205,204,76,77]);
```
- Check the index0ms ‣
```
assert.equal(index, 8);
```
pack to typed array: LE (write to the middle of array)
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [0,0,0,0,  205,204,76,77]);
```
- Check the index0ms ‣
```
assert.equal(index, 8);
```
pack to typed array: BE
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [64,9,112,95,  77,76,204,205]);
```
- Check the index0ms ‣
```
assert.equal(index, 8);
```
pack to typed array: BE (write to the middle of array)
- Check the packed 16-bit values0ms ‣
```
assert.deepEqual(file, [0,0,0,0,  77,76,204,205,  0,0,0,0]);
```
- Check the index0ms ‣
```
assert.equal(index, 8);
```

read: LE

Check the unpacked 16-bit values0ms ‣
```
assert.deepEqual(output, [65535]);
```

Original buffer should be untouched0ms ‣

assert.deepEqual(file, [255, 255, 253, 2, 0, 0, 0, 0]);

read: LE (read from the middle of array)
- Check the unpacked 16-bit values1ms ‣
```
assert.deepEqual(output, [765]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [255, 255, 253, 2, 0, 0, 0, 0]);
```

read: LE (read 2 values)

Check the unpacked 16-bit values0ms ‣
```
assert.deepEqual(output, [65535, 765]);
```

Original buffer should be untouched0ms ‣

assert.deepEqual(file, [255, 255, 253, 2, 0, 0, 0, 0]);

should turn 8 bytes to 1 64-bit float (Uint8Array)0ms ‣

assert.deepEqual(
  btools.read('d', [75,40,253,58,221,154,191,63]),
  [0.123456789876543]);

should turn 8 bytes to 1 64-bit float (Buffer)0ms ‣

assert.deepEqual(
  btools.read('d', [75,40,253,58,221,154,191,63]),
  [0.123456789876543]);

should turn 9 bytes to 1 64-bit float (ignore the extra byte) (Buffer)0ms ‣

assert.deepEqual(
  btools.read('d', [75,40,253,58,221,154,191,63,0]),
  [0.123456789876543]);

read: BE

Check the unpacked 16-bit values0ms ‣
```
assert.deepEqual(output, [65535]);
```

Original buffer should be untouched0ms ‣

assert.deepEqual(file, [255, 255, 2, 253, 0, 0, 0, 0]);

read: BE (read from the middle of array)
- Check the unpacked 16-bit values0ms ‣
```
assert.deepEqual(output, [765]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [255, 255, 2, 253, 0, 0, 0, 0]);
```

readTo: LE

should unpack the values to the provided array0ms ‣

var output = [0,0];
btools.readTo('H', file, output);
    assert.deepEqual(output, [65535, 0]);

should unpack the values to the provided array starting on the index0ms ‣

var index = 0;
var output = [0];
btools.readTo('H', file, output, false, 2);
    assert.deepEqual(output, [0]);

should unpack the values to the provided array starting on the index0ms ‣

var index = 0;
var output = [0];
btools.readTo('H', file, output, false, 1);
    assert.deepEqual(output, [255]);

Original buffer should be untouched0ms ‣

assert.deepEqual(file, [255, 255, 0, 0]);

readTo: BE
- Unpack the first value0ms ‣
```
assert.deepEqual(output, [765, 0]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [2, 253, 0, 0]);
```
unpackFrom: LE
- Unpack the first value0ms ‣
```
assert.deepEqual(value, [65535]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [255, 255, 253, 2]);
```
unpackFrom: LE (read to the middle of array)
- Unpack the second value1ms ‣
```
assert.deepEqual(value, [765]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [255, 255, 253, 2]);
```
unpackFrom: BE
- Unpack the first value0ms ‣
```
assert.deepEqual(value, [65535]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [255, 255, 2, 253]);
```
unpackFrom: BE (read to the middle of array)
- Unpack the first value0ms ‣
```
assert.deepEqual(value, [765]);
```
- Original buffer should be untouched0ms ‣
```
assert.deepEqual(file, [255, 255, 2, 253]);
```

Test calcSize

use calcSize to calc bh0ms ‣

assert.equal(btools.calcSize('bh', true), 3);

use calcSize to calc 32@bh0ms ‣

assert.equal(btools.calcSize('32@bh', true), 4);

use calcSize to calc 32@bh0ms ‣

assert.equal(btools.calcSize('32@bxxxxxxh', true), 4);

use calcSize to calc 32@>bh0ms ‣

assert.equal(btools.calcSize('32@>bh', true), 4);

use calcSize to calc 32@<bh0ms ‣

assert.equal(btools.calcSize('32@<bh', true), 4);

use calcSize to calc 32@<bhbI1ms ‣

assert.equal(btools.calcSize('32@<bhbI', true), 12);

use calcSize to calc 64@bh0ms ‣

assert.equal(btools.calcSize('64@bh', true), 8);

use calcSize to calc 64@>bh0ms ‣

assert.equal(btools.calcSize('64@>bh', true), 8);

use calcSize to calc 64@<bh0ms ‣

assert.equal(btools.calcSize('64@<bh', true), 8);

use calcSize to calc 64@<bhbI0ms ‣

assert.equal(btools.calcSize('64@<bhbI', true), 16);

use calcSize to calc <HHHHHH0ms ‣

assert.equal(btools.calcSize('<HHHHHH'), 12);

use calcSize to calc <HxHHHHH0ms ‣

assert.equal(btools.calcSize('<HxHHHHH', true), 13);

use calcSize to calc <HxHHHHH0ms ‣

//assert.equal(btools.calcSize('<HxHHHHH'), 12); // includePads false
assert.equal(btools.calcSize('<HxHHHHH', true), 13);

use calcSize to calc <HxxHHHHH0ms ‣

//assert.equal(btools.calcSize('<HxxHHHHH'), 12);// includePads false
assert.equal(btools.calcSize('<HxxHHHHH', true), 14);

use calcSize to calc <H2xHHHHH0ms ‣

//assert.equal(btools.calcSize('<H2xHHHHH'), 12);// includePads false
assert.equal(btools.calcSize('<H2xHHHHH', true), 14);

use calcSize to calc <HxHHHHHx0ms ‣

assert.equal(btools.calcSize('<HxHHHHHx', true), 14);

use calcSize to calc HxHHHHHx0ms ‣

assert.equal(btools.calcSize('HxHHHHHx', true), 14);

use calcSize to calc >HxHHHHHx0ms ‣

assert.equal(btools.calcSize('>HxHHHHHx', true), 14);

use calcSize to calc !HxHHHHHx0ms ‣

assert.equal(btools.calcSize('!HxHHHHHx', true), 14);

use calcSize to calc !HxHHHHHx!0ms ‣

assert.equal(btools.calcSize('!HxHHHHHx!', true), 14);

use calcSize to calc bxbt, true0ms ‣

assert.equal(btools.calcSize('bxbt', true), 6);

use calcSize to calc bxbt, true0ms ‣

assert.equal(btools.calcSize('bxbt', true), 6);

use calcSize to calc bxbt, false0ms ‣

//assert.equal(btools.calcSize('bxbt', false), 5);// includePads false

use calcSize to calc output buffer size <Hxx2BxxHx0ms ‣

var buffer = new Array(btools.calcSize('<Hxx2BxxHx', true));
btools.packTo('<Hxx2BxxHx', [1, 1,1, 1], buffer);
assert.deepEqual(
  buffer,
  [1,0, 0,0, 1,1, 0,0, 1,0, 0]);

use calcSize to calc output buffer size <H2x2B2xHx0ms ‣

var buffer = new Array(btools.calcSize('<H2x2B2xHx', true));
btools.packTo('<H2x2BxxHx', [1, 1,1, 1], buffer);
assert.deepEqual(
  buffer,
  [1,0, 0,0, 1,1, 0,0, 1,0, 0]);

use calcSize to calc output buffer size <Hxx2BxxH0ms ‣

var buffer = new Array(btools.calcSize('<Hxx2BxxH', true));
btools.packTo('<Hxx2BxxH', [1, 1,1, 1], buffer);
assert.deepEqual(
  buffer,
  [1,0, 0,0, 1,1, 0,0,  1,0]);

use calcSize to calc output buffer size <Hxx2BxxH0ms ‣

var buffer = new Array(btools.calcSize('<H2x2BxxH', true));
btools.packTo('<Hxx2B2xH', [1, 1,1, 1], buffer);
assert.deepEqual(
  buffer,
  [1,0, 0,0, 1,1, 0,0,  1,0]);

Test calcSize errors

calcSize() throws error if format is not a string0ms ‣

assert.throws(
  function() {
    btools.calcSize(2);
  },
  /Unsupported type/);

calcSize() throws error if format contains invalid code0ms ‣

assert.throws(
  function() {
    btools.calcSize('Z');
  },
  /Unsupported type/);

calcSize() throws error if format is NaN0ms ‣

assert.throws(
  function() {
    btools.calcSize(NaN);
  },
  /Unsupported type/);

calcSize() throws error if format is {}0ms ‣

assert.throws(
  function() {
    btools.calcSize({});
  },
  /Unsupported type/);

Clamp 8-bit ints

pack b clamp -129 to -1281ms ‣

assert.deepEqual(
  btools.unpack('b', btools.pack('b', -129, true))[0],
  -128);

pack b clamp 128 to 1270ms ‣

assert.deepEqual(
  btools.unpack('b', btools.pack('b', 128, true))[0],
  127);

pack B clamp -1 to 00ms ‣

assert.deepEqual(
  btools.unpack('B', btools.pack('B', -1, true))[0],
  0);

pack B clamp 300 to 2550ms ‣

assert.deepEqual(
  btools.unpack('B', btools.pack('B', 300, true))[0],
  255);

test the endianness() function

change endianness, 32bit0ms ‣

var array = [0,1,2,3,0,1,2,3];
  btools.endianness(array, 4, 0, array.length);
  assert.deepEqual(array, [3,2,1,0,3,2,1,0]);

change endianness, 16bit1ms ‣

var array = [0,1,2,3,0,1,2,3];
  btools.endianness(array, 2, 0, array.length);
  assert.deepEqual(array, [1,0,3,2,1,0,3,2]);

change endianness, 16bit0ms ‣

var array = [0,1,2,3,0,1,2,3];
btools.endianness(array, 2, 0, 6);
assert.deepEqual(array, [1,0,3,2,1,0,2,3]);

change endianness, 16bit0ms ‣

var array = [0,1,2,3,0,1,2,3];
btools.endianness(array, 2, 2, 6);
assert.deepEqual(array, [0,1,3,2,1,0,2,3]);

change endianness, 16bit0ms ‣

var array = [0,1,2,3,0,1,2,3];
  btools.endianness(array, 2, 2, array.length);
  assert.deepEqual(array, [0,1,3,2,1,0,3,2]);

change endianness, 8bit (do nothing)0ms ‣

var array = [0,1,2,3,0,1,2,3];
  btools.endianness(array, 1);
  assert.deepEqual(array, [0,1,2,3,0,1,2,3]);

Test format strings

pack H2H0ms ‣

assert.deepEqual(
  btools.pack('<H2H', [1, 1, 1]),
  [1, 0,   1, 0,   1, 0]);

pack H2H0ms ‣

assert.deepEqual(
  btools.pack('<2HH', [1, 1, 1]),
  [1, 0,   1, 0,   1, 0]);

pack 2H2H0ms ‣

assert.deepEqual(
  btools.pack('<2H3H', [1, 1, 1, 1, 1]),
  [1, 0,   1, 0,   1, 0,   1, 0,   1, 0]);

pack 2H2H0ms ‣

assert.deepEqual(
  btools.pack('<3H2H', [1, 1, 1, 1, 1]),
  [1, 0,   1, 0,   1, 0,   1, 0,   1, 0]);

pack 2H2H2H1ms ‣

assert.deepEqual(
  btools.pack('<3H2H2H', [1, 1, 1, 1, 1, 1, 1]),
  [1, 0,   1, 0,   1, 0,   1, 0,   1, 0,   1, 0,   1, 0]);

pack s2s0ms ‣

assert.deepEqual(
  btools.pack('<s2s', ['a', 'ba']),
  [97,   98, 97]);

pack 2ss0ms ‣

assert.deepEqual(
  btools.pack('<2ss', ['ab', 'a']),
  [97, 98,   97]);

pack 2s3s0ms ‣

assert.deepEqual(
  btools.pack('<2s3s', ['ab','aba']),
  [97, 98,   97, 98, 97]);

pack 3s2s0ms ‣

assert.deepEqual(
  btools.pack('<3s2s', ['aba', 'ba']),
  [97, 98, 97,   98, 97]);

pack 3s2s2s0ms ‣

assert.deepEqual(
  btools.pack('<3s2s2s', ['aba', 'ba', 'ba']),
  [97, 98, 97,   98, 97,   98, 97]);

pack ss0ms ‣

assert.deepEqual(
  btools.pack('<ss', ['a', 'b']),
  [97,   98]);

pack u2u1ms ‣

assert.deepEqual(
  btools.pack('<u2u', ['a', 'ba']),
  [97,   98, 97]);

pack 2uu0ms ‣

assert.deepEqual(
  btools.pack('<2uu', ['ab', 'a']),
  [97, 98,   97]);

pack 2u3u0ms ‣

assert.deepEqual(
  btools.pack('<2u3u', ['ab','aba']),
  [97, 98,   97, 98, 97]);

pack 3u2u0ms ‣

assert.deepEqual(
  btools.pack('<3u2u', ['aba', 'ba']),
  [97, 98, 97,   98, 97]);

pack 3u2u2u0ms ‣

assert.deepEqual(
  btools.pack('<3u2u2u', ['aba', 'ba', 'ba']),
  [97, 98, 97,   98, 97,   98, 97]);

pack uu0ms ‣

assert.deepEqual(
  btools.pack('<uu', ['a', 'b']),
  [97,   98]);

pack uuh0ms ‣

assert.deepEqual(
  btools.pack('<uuh', ['a', 'b', 1]),
  [97,   98,   1, 0]);

pack uu2h0ms ‣

assert.deepEqual(
  btools.pack('<uu2h', ['a', 'b', 1, 1]),
  [97,   98,   1, 0,   1, 0]);

pack uuhh0ms ‣

assert.deepEqual(
  btools.pack('<uuhh', ['a', 'b', 1, 1]),
  [97,   98,   1, 0,   1, 0]);

pack uu2hu0ms ‣

assert.deepEqual(
  btools.pack('<uu2hu', ['a', 'b', 1, 1, 'a']),
  [97,   98,   1, 0,   1, 0,   97]);

pack uuhhu0ms ‣

assert.deepEqual(
  btools.pack('<uuhhu', ['a', 'b', 1, 1, 'a']),
  [97,   98,   1, 0,   1, 0,   97]);

pack H0BH0ms ‣

assert.deepEqual(
  btools.pack('<H0BH', [1,1,1]),
  [1, 0,  1,  1, 0]);

pack H10BH0ms ‣

assert.deepEqual(
  btools.pack('<H10BH', [1, 1,1,1,1,1,1,1,1,1,1, 1]),
  [1, 0,   1,1,1,1,1,1,1,1,1,1,  1, 0]);

pack <H11BH1ms ‣

assert.deepEqual(
  btools.pack('<H11BH', [1, 1,1,1,1,1,1,1,1,1,1,1, 1]),
  [1, 0,   1,1,1,1,1,1,1,1,1,1,1,  1, 0]);

pack <H101BH0ms ‣

assert.deepEqual(
  btools.pack('<H101BH', [1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1]),
  [1, 0,   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  1, 0]);

pack <H2BH0ms ‣

assert.deepEqual(
  btools.pack('<H2BH', [1, 1,1, 1]),
  [1, 0,  1,1,  1, 0]);

pack <H0ms ‣

assert.deepEqual(
  btools.pack('<H', 1),
  [1, 0]);

pack >H0ms ‣

assert.deepEqual(
  btools.pack('>H', 1),
  [0, 1]);

pack H0ms ‣

assert.deepEqual(
  btools.pack('H', 1),
  [1, 0]);

pack <H2 (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('<H2', 1),
  [1, 0]);

pack <H22 (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('<H22', 1),
  [1, 0]);

pack <HH22 (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('<HH22', [1, 1]),
  [1, 0, 1, 0]);

pack >H> (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('>H>', 1),
  [0, 1]);

pack >HH> (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('>HH>', [1, 1]),
  [0, 1, 0, 1]);

pack >HH>> (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('>HH>>', [1, 1]),
  [0, 1, 0, 1]);

pack >HH>>2< (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('>HH>>2<', [1, 1]),
  [0, 1, 0, 1]);

pack >H<H> (junk in the format string)1ms ‣

assert.deepEqual(
  btools.pack('>H<H>', [1, 1]),
  [0, 1, 0, 1]);

pack !H<H> (junk in the format string)0ms ‣

assert.deepEqual(
  btools.pack('!H<H>', [1, 1]),
  [0, 1, 0, 1]);

pack !H!H! (junk in the format string)1ms ‣

assert.deepEqual(
  btools.pack('!H!H!', [1, 1]),
  [0, 1, 0, 1]);

pack H4< (junk in the format string)1ms ‣

assert.deepEqual(
  btools.pack('H4<', 1),
  [1, 0]);

packTo uInt16 (65535, 16) with < representing little-endian0ms ‣

var buffer = new Array(2);
btools.packTo('<H', 1, buffer);
assert.deepEqual(
  buffer,
  [1, 0]);

packTo >H0ms ‣

var buffer = new Array(2);
btools.packTo('>H', 1, buffer);
assert.deepEqual(
  buffer,
  [0, 1]);

packTo !H0ms ‣

var buffer = new Array(2);
btools.packTo('!H', 1, buffer);
assert.deepEqual(
  buffer,
  [0, 1]);

packTo !H!0ms ‣

var buffer = new Array(2);
btools.packTo('!H!', 1, buffer);
assert.deepEqual(
  buffer,
  [0, 1]);

packTo >H, larger buffer0ms ‣

var buffer = ['x', 'x', 0, 0, 'x', 'x'];
btools.packTo('>H', 1, buffer, false, 2);
assert.deepEqual(
  buffer,
  ['x', 'x', 0, 1, 'x', 'x']);

packTo !H, larger buffer0ms ‣

var buffer = ['x', 'x', 0, 0, 'x', 'x'];
btools.packTo('!H', 1, buffer, false, 2);
assert.deepEqual(
  buffer,
  ['x', 'x', 0, 1, 'x', 'x']);

packTo H0ms ‣

var buffer = new Array(2);
btools.packTo('H', 1, buffer);
assert.deepEqual(
  buffer,
  [1, 0]);

packTo HH0ms ‣

var buffer = new Array(4);
btools.packTo('HH', [1, 1], buffer);
assert.deepEqual(
  buffer,
  [1, 0, 1, 0]);

packTo HHh0ms ‣

var buffer = new Array(6);
btools.packTo('HHh', [1, 1, 1], buffer);
assert.deepEqual(
  buffer,
  [1, 0, 1, 0, 1, 0]);

pack HH0ms ‣

var buffer = btools.pack('HH', [1, 1]);
assert.deepEqual(
  buffer,
  [1, 0, 1, 0]);

pack HHh0ms ‣

var buffer = btools.pack('HHh', [1, 1, 1]);
assert.deepEqual(
  buffer,
  [1, 0, 1, 0, 1, 0]);

pack HHhh0ms ‣

var buffer = btools.pack('HHhh', [1, 1, 1, 1]);
assert.deepEqual(
  buffer,
  [1, 0, 1, 0, 1, 0, 1, 0]);

Test errors related to format strings

throw error if ouput buffer dont have sufficient size0ms ‣

var buffer = new Array(1);
btools.packTo('H', 1, buffer);
assert.deepEqual(buffer, [1, 0]);

do not throw error if ouput buffer dont have sufficient size0ms ‣

var buffer = new Array(1);
btools.packTo('H', 1, buffer);
assert.deepEqual(buffer, [1, 0]);

do not throw error if ouput buffer dont have sufficient size (Array)1ms ‣

var buffer = new Array(1);
btools.packTo('>H', 1, buffer);
assert.deepEqual(buffer, [0,1]);

throw error if input dont have enough elements0ms ‣

var testFunc = function() {
  var buffer = new Array(3);
  btools.packTo('HH', 3, buffer);
};
assert.throws(testFunc, /Number of values do not match the format/);

dont throw error if ouput buffer size bad for for ffH (Array)0ms ‣

var buffer = new Array(9);
btools.packTo('ffH', [0,0,0], buffer);
assert.deepEqual(buffer, [0,0,0,0,0,0,0,0,0,0]);

throw error if value length dont match format length0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo('HH', [1], buffer);
};
assert.throws(testFunc, /Number of values do not match the format/);

throw error if value length dont match format length0ms ‣

var testFunc = function() {
  //var buffer = new Array(4);
  var buffer = new Array(14);
  btools.packTo('H10xH', [1], buffer);
};
assert.throws(testFunc, /Number of values do not match the format/);

Ignore extra values if present0ms ‣

var buffer = [null, null, null, null,  null, null, null, null];
btools.packTo('HH', [1,1,1], buffer);
assert.deepEqual(
  buffer,
  [1, 0, 1, 0,  null, null, null, null]);

Ignore extra values if present, pad bytes0ms ‣

//var buffer = [null, null, null, null,  null, null, null, null];
var buffer = [null, null, null, null,  null, null, null, null, null, null, null, null, null, null];
btools.packTo('H10xH', [1,1,1,23], buffer);
assert.deepEqual(
  buffer,
  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]);

throw error if type is not a format string1ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo(1, 1, buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is not a type object or format string0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo(null, 1, buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is not a defined type0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo('G', 1, buffer);
  console.log(buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is NaN0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo(NaN, 1, buffer);
  console.log(buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is [NaN]0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo([NaN], 1, buffer);
  console.log(buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is <0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo('<', 1, buffer);
  console.log(buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is >0ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo('>', 1, buffer);
  console.log(buffer);
};
assert.throws(testFunc, /Unsupported type/);

throw error if type is !1ms ‣

var testFunc = function() {
  var buffer = new Array(4);
  btools.packTo('!', 1, buffer);
  console.log(buffer);
};
assert.throws(testFunc, /Unsupported type/);

binary32 and binary64 in an env with no Uint8Array

pack pi as 3.14159265358979310ms ‣

global.Uint8Array = undefined;
assert.deepEqual(
  btools.pack('d', 3.1415926535897931), 
  [0x18,0x2d,0x44,0x54,0xfb,0x21,0x09,0x40]);
global.Uint8Array = tmp;

unpack pi as 3.14159265358979310ms ‣

global.Uint8Array = undefined;
assert.equal(
  btools.unpack(
    'd', [0x18,0x2d,0x44,0x54,0xfb,0x21,0x09,0x40])[0].toFixed(15), 
  '3.141592653589793');
global.Uint8Array = tmp;

pack pi as 3.14159274100ms ‣

global.Uint8Array = undefined;
assert.deepEqual(
  btools.pack('f', 3.1415927410), 
  [0xdb,0x0F,0x49,0x40]);
global.Uint8Array = tmp;

unpack pi as 3.14159274100ms ‣

global.Uint8Array = undefined;
assert.equal(
  btools.unpack('f', [0xdb,0x0F,0x49,0x40])[0].toFixed(10), 
  '3.1415927410');
global.Uint8Array = tmp;

interface

pack true uInt16 (1, 0) should raise a NaN error0ms ‣

assert.throws(
  function() {
    btools.pack('H', true);
  },
  ///index 0 \(true\)/);
  /true/);

pack false uInt16 (0, 0) should raise a NaN error1ms ‣

assert.throws(
  function() {
    btools.pack('H', false);
  },
  ///index 0 \(false\)/);
  /false/);

pack uInt16 (65535, 16)0ms ‣

assert.deepEqual(
  btools.pack('H', 65535),
  [255,255]);

pack float32 (2.1474836, 16)0ms ‣

assert.deepEqual(
  btools.pack('f', 2.1474836),
  [95,112,9,64]);

pack uInt8 (254)0ms ‣

assert.deepEqual(
  btools.pack('B', 254),
  [254]);

pack uInt8 (255)0ms ‣

assert.deepEqual(
  btools.pack('B', 255),
  [255]);

pack int8 (-1)0ms ‣

assert.deepEqual(
  btools.pack('b', -1),
  [255]);

pack int8 (-2)0ms ‣

assert.deepEqual(
  btools.pack('b', -2),
  [254]);

throws a TypeError if packString value is a number0ms ‣

var testFunc = function() {
  btools.packString(1);
};
assert.throws(testFunc, TypeError);

unpack uInt160ms ‣

assert.deepEqual(
  btools.unpack('H', [255, 255])[0],
  65535);

unpack float160ms ‣

assert.equal(
  btools.unpack('e', [85, 53])[0].toFixed(5),
  0.33325);

unpack uInt160ms ‣

assert.equal(
  btools.unpack('H', [255,255])[0],
  65535);

packArray uInt160ms ‣

assert.deepEqual(
  btools.write('H', [65535, 0]),
  [255, 255, 0, 0]);

packArray int320ms ‣

assert.deepEqual(
  btools.write('l', [-2147483648, 2147483647]),
  [0,0,0,128,255,255,255,127]);

packArray float320ms ‣

assert.deepEqual(btools.write('f', [-1, 1]),
  [0,0,128,191,0,0,128,63]);

should ignore repeat count numbers on write()0ms ‣

assert.deepEqual(btools.write('6f', [-1, 1]),
  [0,0,128,191,0,0,128,63]);

should ignore repeat count numbers on write()0ms ‣

assert.deepEqual(btools.write('1f', [-1, 1]),
  [0,0,128,191,0,0,128,63]);

read uInt160ms ‣

assert.deepEqual(
  btools.read('H', [255, 255, 0, 0]),
  [65535, 0]);

should ignore repeat count numbers on read()1ms ‣

assert.deepEqual(
  btools.read('1H', [255, 255, 0, 0]),
  [65535, 0]);

read float640ms ‣

assert.deepEqual(
  btools.read('d', [0,0,0,0,0,0,240,63]),
  [1]);

read behaviour tests

Throws bad buffer length error if not enough bytes (32 bit)0ms ‣

var a = function() {
  btools.read('f', [95,112,9]);
};
assert.throws(a, /Bad buffer length/);

Ignores extra bytes for 32-bit values0ms ‣

assert.deepEqual(
  btools.read('l', [0,0,0,128, 255,255,255,127,255,128]),
  [-2147483648,2147483647]);

Ignores extra bytes for 24-bit values0ms ‣

assert.deepEqual(
  btools.read('T', [0,0,0,255,255,255,255]),
  [0,16777215]);

Throws bad buffer length error if not enough bytes (24 bit)1ms ‣

var a = function() {
  btools.read('T', [255,255]);
};
assert.throws(a, /Bad buffer length/);

utf8BufferSize() tests

= 00ms ‣

assert.deepEqual(btools.utf8BufferSize(''), 0);

aa = 20ms ‣

assert.deepEqual(btools.utf8BufferSize('aa'), 2);

輸 = 40ms ‣

assert.deepEqual(btools.utf8BufferSize('輸'), 4);

輸輸 = 80ms ‣

assert.deepEqual(btools.utf8BufferSize('輸輸'), 8);

輸輸aa = 100ms ‣

assert.deepEqual(btools.utf8BufferSize('輸輸aa'), 10);

utf16BufferSize() tests

= 00ms ‣

assert.deepEqual(btools.utf16BufferSize(''), 0);

a = 20ms ‣

assert.deepEqual(btools.utf16BufferSize('a'), 2);

aa = 40ms ‣

assert.deepEqual(btools.utf16BufferSize('aa'), 4);

輸 = 40ms ‣

assert.deepEqual(btools.utf16BufferSize('輸'), 4);

輸輸 = 80ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸'), 8);

輸輸aa = 120ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸aa'), 12);

BOM + 輸輸aa = 140ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸aa'), 14);

forceBOM=true then 輸輸aa = 120ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸aa', true), 14);

forceBOM=false then 輸輸aa = 120ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸aa', false), 12);

forceBOM=true then BOM + 輸輸aa = 140ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸aa', true), 14);

forceBOM=false then BOM + 輸輸aa = 140ms ‣

assert.deepEqual(btools.utf16BufferSize('輸輸aa', false), 14);

error on lonely high surrogate0ms ‣

var a = function() {
  btools.utf16BufferSize('\ud800');
};
assert.throws(a, /Invalid UTF-16 character/);

error on lonely low surrogate0ms ‣

var a = function() {
  btools.utf16BufferSize('\udc00');
};
assert.throws(a, /Invalid UTF-16 character/);

utf32BufferSize() tests

= 00ms ‣

assert.deepEqual(btools.utf32BufferSize(''), 0);

a = 20ms ‣

assert.deepEqual(btools.utf32BufferSize('a'), 4);

aa = 40ms ‣

assert.deepEqual(btools.utf32BufferSize('aa'), 8);

輸 = 40ms ‣

assert.deepEqual(btools.utf32BufferSize('輸'), 4);

輸輸 = 80ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸'), 8);

輸輸aa = 120ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸aa'), 16);

BOM + 輸輸aa = 140ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸aa'), 20);

forceBOM=true then 輸輸aa = 120ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸aa', true), 20);

forceBOM=false then 輸輸aa = 120ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸aa', false), 16);

forceBOM=true then BOM + 輸輸aa = 140ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸aa', true), 20);

forceBOM=false then BOM + 輸輸aa = 140ms ‣

assert.deepEqual(btools.utf32BufferSize('輸輸aa', false), 20);

error on lonely high surrogate0ms ‣

var a = function() {
  btools.utf32BufferSize('\ud800');
};
assert.throws(a, /Invalid UTF-32 character/);

error on lonely low surrogate0ms ‣

var a = function() {
  btools.utf32BufferSize('\udc00');
};
assert.throws(a, /Invalid UTF-32 character/);

error on lonely low surrogate0ms ‣

var a = function() {
  btools.utf32BufferSize('\udc00\ud800');
};
assert.throws(a, /Invalid UTF-32 character/);

hexToBytes and bytesToHex tests

= []1ms ‣

assert.deepEqual(btools.hexToBytes(''), []);

ff = [255]0ms ‣

assert.deepEqual(btools.hexToBytes('ff'), [255]);

ffff = [255, 255]0ms ‣

assert.deepEqual(btools.hexToBytes('ffff'), [255, 255]);

ffFf = [255, 255]0ms ‣

assert.deepEqual(btools.hexToBytes('ffFf'), [255, 255]);

ffff00 = [255, 255, 0]0ms ‣

assert.deepEqual(btools.hexToBytes('ffff00'), [255, 255, 0]);

ffff0 = [255, 255, 0]0ms ‣

assert.deepEqual(btools.hexToBytes('ffff00'), [255, 255, 0]);

[] = 0ms ‣

assert.deepEqual(btools.bytesToHex([]), '');

[255] = ff0ms ‣

assert.deepEqual(btools.bytesToHex([255]), 'ff');

[255, 255] = ffff0ms ‣

assert.deepEqual(btools.bytesToHex([255, 255]), 'ffff');

[255, 255, 0] = ffff000ms ‣

assert.deepEqual(btools.bytesToHex([255, 255, 0]), 'ffff00');

[-1, 255, 0] throws RangeError0ms ‣

var a = function() {
  btools.bytesToHex([-1, 255, 0]);
};
assert.throws(a, RangeError);

[256, 255, 0] throws RangeError0ms ‣

var a = function() {
  btools.bytesToHex([256, 255, 0]);
};
assert.throws(a, RangeError);

fffff throws Error0ms ‣

var a = function() {
  btools.hexToBytes('fffff');
};
assert.throws(a, Error);

ffffxf throws RangeError0ms ‣

var a = function() {
  btools.hexToBytes('ffffxf');
};
assert.throws(a, RangeError);

Errors

bad buffer len, writeTo Array0ms ‣

var b = [];
btools.writeTo('H', [0], b);
assert.deepEqual(b, [0, 0]);

throws errors with correct index when packing0ms ‣

var testFunc = function() {
  btools.write('H', [0, '1']);
};
//assert.throws(testFunc, /index 1 ()/);
assert.throws(testFunc, TypeError);

thows error if packing something other than Number, Boolean or null1ms ‣

var testFunc = function() {
  btools.pack('H', {some: 'thing'});
};
assert.throws(testFunc, Error);

undefined value0ms ‣

var testFunc = function() {
  btools.pack('B', undefined);
};
//assert.throws(testFunc, /index 0 \(undefined\)/);
assert.throws(testFunc, TypeError);

null value0ms ‣

var testFunc = function() {
  btools.pack('B', null);
};
//assert.throws(testFunc, /index 0 \(null\)/);
assert.throws(testFunc, /null/);

string value0ms ‣

var testFunc = function() {
  btools.pack('B', 'c');
};
//assert.throws(testFunc, /index 0 \(c\)/);
assert.throws(testFunc, /c/);

undefined value, index 10ms ‣

var testFunc = function() {
  btools.write('B', [0, undefined]);
};
//assert.throws(testFunc, /index 1 \(undefined\)/);
//assert.throws(testFunc, /undefined/);
assert.throws(testFunc, TypeError);

Infinity value, index 11ms ‣

var testFunc = function() {
  btools.write('B', [0, Infinity]);
};
//assert.throws(testFunc, /index 1 \(Infinity\)/);
assert.throws(testFunc, /Infinity/);

-Infinity value, index 10ms ‣

var testFunc = function() {
  btools.write('B', [0, -Infinity]);
};
//assert.throws(testFunc, /index 1 \(-Infinity\)/);
assert.throws(testFunc, /-Infinity/);

NaN value, index 10ms ‣

var testFunc = function() {
  btools.write('B', [0, NaN]);
};
//assert.throws(testFunc, /index 1 \(NaN\)/);
assert.throws(testFunc, /NaN/);

char, index 10ms ‣

var testFunc = function() {
  btools.write('B', [0, 'a']);
};
//assert.throws(testFunc, /index 1 \(a\)/);
assert.throws(testFunc, /a/);

thows error if packing something other than Number or Boolean (float)0ms ‣

var testFunc = function() {
  btools.pack('f', {some: 'thing'});
};
assert.throws(testFunc, Error);

undefined value1ms ‣

var testFunc = function() {
  btools.pack('f', undefined);
};
//assert.throws(testFunc, /index 0 \(undefined\)/);
//assert.throws(testFunc, /undefined/);
assert.throws(testFunc, TypeError);

null value0ms ‣

var testFunc = function() {
  btools.pack('f', null);
};
//assert.throws(testFunc, /index 0 \(null\)/);
assert.throws(testFunc, /null/);

string value0ms ‣

var testFunc = function() {
  btools.pack('f', 'c');
};
//assert.throws(testFunc, /index 0 \(c\)/);
assert.throws(testFunc, /c/);

undefined value, index 10ms ‣

var testFunc = function() {
  btools.write('f', [0, undefined]);
};
//assert.throws(testFunc, /index 1 \(undefined\)/);
//assert.throws(testFunc, undefined);
assert.throws(testFunc, TypeError);

char, index 10ms ‣

var testFunc = function() {
  btools.write('f', [0, 'a']);
};
//assert.throws(testFunc, /index 1 \(a\)/);
assert.throws(testFunc, /a/);

Bad buffer length on unpack, missing a byte, safe mode0ms ‣

var testFunc = function() {
  btools.unpack('H', [1], 0, true);
};
assert.throws(testFunc, /Bad buffer length/);

Bad buffer length on unpack, zero bytes, safe mode0ms ‣

var testFunc = function() {
  btools.unpack('H', [], 0, true);
};
assert.throws(testFunc, /Bad buffer length/);

8-bit overflow, positive0ms ‣

var testFunc = function() {
  btools.pack('B', 256);
};
//assert.throws(testFunc, /index 0 \(256\)/);
assert.throws(testFunc, /256/);

8-bit overflow, negative0ms ‣

var testFunc = function() {
  btools.pack('B', -1);
};
//assert.throws(testFunc, /index 0 \(-1\)/);
assert.throws(testFunc, /-1/);

8-bit overflow, negative, index 21ms ‣

var testFunc = function() {
  btools.write('B', [1, -1]);
};
//assert.throws(testFunc, /index 1 \(-1\)/);
assert.throws(testFunc, /-1/);

type is a empty array0ms ‣

var testFunc = function() {
  console.log(btools.pack([], 2));
};
assert.throws(testFunc, /Unsupported type/);

type is a empty object0ms ‣

var testFunc = function() {
  console.log(btools.pack({}, 2));
};
assert.throws(testFunc, /Unsupported type/);

pack type is a number0ms ‣

var testFunc = function() {
  console.log(btools.pack(1, 2));
};
assert.throws(testFunc, /Unsupported type/);

unpack type is a number0ms ‣

var testFunc = function() {
  console.log(btools.unpack(1, [2]));
};
assert.throws(testFunc, /Unsupported type/);

write type is a number0ms ‣

var testFunc = function() {
  console.log(btools.write(1, [2]));
};
assert.throws(testFunc, /Unsupported type/);

read type is a number0ms ‣

var testFunc = function() {
  console.log(btools.read(1, [2]));
};
assert.throws(testFunc, /Unsupported type/);

writeTo type is a number0ms ‣

var testFunc = function() {
  var buffer = new Array(2);
  console.log(btools.writeTo(1, [2], buffer));
};
assert.throws(testFunc, /Unsupported type/);

readTo type is a number0ms ‣

var testFunc = function() {
  var buffer = new Array(2);
  console.log(btools.readTo(1, [2], buffer));
};
assert.throws(testFunc, /Unsupported type/);

-1bit)0ms ‣

//btools.types.Z = {'bits': -1};
//btools.setType('Z', {'bits': -1});
var testFunc = function() {
  //btools.pack('Z', 2);
  btools.setType('Z', -1);
};
assert.throws(testFunc, /Unsupported type/);

17 float (-1)0ms ‣

//btools.types.Z = {'bits': 17, 'fp': true};
//btools.setType('Z', {'bits': 17, 'fp': true});
var testFunc = function() {
  //btools.pack('Z', 2);
  btools.setType('Z', -17);
};
assert.throws(testFunc, /Unsupported type/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('H', [-1]);
};
//assert.throws(testFunc, /index 0 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('HH', [0, -1]);
};
//assert.throws(testFunc, /index 1 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('2H', [0, -1]);
};
//assert.throws(testFunc, /index 1 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError1ms ‣

var testFunc = function() {
  btools.pack('BH', [0, -1]);
};
//assert.throws(testFunc, /index 1 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('BH', [0, -1]);
};
//assert.throws(testFunc, /index 1 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('lH', [0, -1]);
};
//assert.throws(testFunc, /index 1 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError1ms ‣

var testFunc = function() {
  btools.pack('lHH', [0, 0, -1]);
};
//assert.throws(testFunc, /index 2 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('HB', [-1, 0]);
};
//assert.throws(testFunc, /index 0 \(-1\)/);
assert.throws(testFunc, /-1/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('h', [NaN]);
};
//assert.throws(testFunc, /index 0 \(NaN\)/);
assert.throws(testFunc, /NaN/);

shows the correct index and value on RangeError1ms ‣

var testFunc = function() {
  btools.pack('hh', [0, NaN]);
};
//assert.throws(testFunc, /index 1 \(NaN\)/);
assert.throws(testFunc, /NaN/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('2h', [0, NaN]);
};
//assert.throws(testFunc, /index 1 \(NaN\)/);
assert.throws(testFunc, /NaN/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('Bh', [0, NaN]);
};
//assert.throws(testFunc, /index 1 \(NaN\)/);
assert.throws(testFunc, /NaN/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('Bh', [0, NaN]);
};
//assert.throws(testFunc, /index 1 \(NaN\)/);
assert.throws(testFunc, /NaN/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('hB', [NaN, 0]);
};
//assert.throws(testFunc, /index 0 \(NaN\)/);
assert.throws(testFunc, /NaN/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('f', ['a']);
};
//assert.throws(testFunc, /index 0 \(a\)/);
assert.throws(testFunc, /a/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('ff', [0, 'a']);
};
//assert.throws(testFunc, /index 1 \(a\)/);
assert.throws(testFunc, /a/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('2f', [0, 'a']);
};
//assert.throws(testFunc, /index 1 \(a\)/);
assert.throws(testFunc, /a/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('Bf', [0, 'a']);
};
//assert.throws(testFunc, /index 1 \(a\)/);
assert.throws(testFunc, /a/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('Bf', [0, 'a']);
};
//assert.throws(testFunc, /index 1 \(a\)/);
assert.throws(testFunc, /a/);

shows the correct index and value on RangeError1ms ‣

var testFunc = function() {
  btools.pack('fB', ['a', 0]);
};
//assert.throws(testFunc, /index 0 \(a\)/);
assert.throws(testFunc, /a/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('s', ['ç']);
};
//assert.throws(testFunc, /index 0 \(ç\)/);
assert.throws(testFunc, /ç/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('2s', ['aç']);
};
//assert.throws(testFunc, /index 0 \(ç\)/);
assert.throws(testFunc, /ç/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('H2s', [0, 'aÿ']);
};
//assert.throws(testFunc, /index 1 \(ÿ\)/);
assert.throws(testFunc, /ÿ/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('B2s', [0, 'aç']);
};
//assert.throws(testFunc, /index 1 \(ç\)/);
assert.throws(testFunc, /ç/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('H2s', [0, 'aç']);
};
//assert.throws(testFunc, /index 1 \(ç\)/);
assert.throws(testFunc, /ç/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.pack('2sB', ['aç', 0]);
};
//assert.throws(testFunc, /index 0 \(ç\)/);
assert.throws(testFunc, /ç/);

shows the correct index and value on RangeError0ms ‣

var testFunc = function() {
  btools.write('s', ['aç']);
};
//assert.throws(testFunc, /index 0 \(ç\)/);
assert.throws(testFunc, /ç/);

pack-unpack

should turn 8 bytes to 1 64-bit float and back (10ms ‣

var bytes = btools.write('d', [612345678987654.3]);
var num = btools.read('d', bytes);
assert.deepEqual(num, [612345678987654.3]);

should turn 8 bytes to 1 64-bit float and back (10ms ‣

var bytes = btools.write('d', [612345678.9876543]);
var num = btools.read('d', bytes);
assert.deepEqual(num[0], 612345678.9876543);

should turn 8 bytes to 1 64-bit float and back (10ms ‣

var bytes = btools.write('d', [612345678.9876543]);
var num = btools.read('d', bytes);
assert.ok(num != [612345678.9876540]);

should turn 8 bytes to 1 64-bit float and back (1 round)0ms ‣

var bytes = btools.write('d', [612345678987654.3]);
var num = btools.read('d', bytes);
assert.ok(num[0] != 612345678987654.1);

should turn 8 bytes to 1 64-bit float and back0ms ‣

var bytes = btools.write('d', [0.123456789876543]);
var num = btools.read('d', bytes)[0];
var r = 0.123456789876543;
// account for rounding differences in old JS engines
assert.deepEqual(r.toFixed(15), num.toFixed(15));

should turn 8 bytes to 1 64-bit float and back (precision)0ms ‣

var bytes = btools.write('d', [0.123456789876543]);
var num = btools.read('d', bytes);
assert.ok(0.123456789876544 != num[0]);

should turn 6 bytes (hex) to 1 unsigned 48-bit int (max range)0ms ‣

var bytes = btools.write('k', [1]);
var num = btools.read('k', bytes);
assert.equal(1, num[0]);

should turn 6 bytes (hex) to 1 unsigned 48-bit int (max range)0ms ‣

var bytes = btools.write('k', [11]);
var num = btools.read('k', bytes);
assert.equal(11, num[0]);

should turn 6 bytes (hex) to 1 unsigned 48-bit int (max range)0ms ‣

var bytes = btools.write('K', [0]);
var num = btools.read('K', bytes);
assert.equal(0, num[0]);

should turn 6 bytes (hex) to 1 unsigned 48-bit int (max range)0ms ‣

var bytes = btools.write('K', [281474976710655]);
var num = btools.read('K', bytes);
assert.equal(281474976710655, num[0]);

should turn 6 bytes (hex) to 1 signed 48-bit int (max range)0ms ‣

var bytes = btools.write('k', [140737488355327]);
var num = btools.read('k', bytes);
assert.equal(140737488355327, num[0]);

should turn 6 bytes (hex) to 1 signed 48-bit int (min range)0ms ‣

var bytes = btools.write('k', [-140737488355328]);
var num = btools.read('k', bytes);
assert.equal(-140737488355328, num[0]);

should turn 5 bytes (hex) to 1 unsigned 40-bit int (1)1ms ‣

var bytes = btools.write('J', [1]);
var num = btools.read('J', bytes);
assert.equal(1, num[0]);

should turn 5 bytes (hex) to 1 unsigned 40-bit int (11)0ms ‣

var bytes = btools.write('J', [11]);
var num = btools.read('J', bytes);
assert.equal(11, num[0]);

should turn 5 bytes (hex) to 1 unsigned 40-bit int (0)0ms ‣

var bytes = btools.write('J', [0]);
var num = btools.read('J', bytes);
assert.equal(0, num[0]);

should turn 5 bytes (hex) to 1 unsigned 40-bit int (max range)0ms ‣

var bytes = btools.write('J', [1099511627775]);
var num = btools.read('J', bytes);
assert.equal(1099511627775, num[0]);

should turn 5 bytes (hex) to 1 signed 40-bit int (max range)0ms ‣

var bytes = btools.write('j',[549755813887]);
var num = btools.read('j', bytes);
assert.equal(549755813887, num[0]);

should turn 5 bytes (hex) to 1 signed 40-bit int (min range)0ms ‣

var bytes = btools.write('j', [-549755813888]);
var num = btools.read('j', bytes);
assert.equal(-549755813888, num[0]);

should turn 1 32-bit float to 4 bytes and back (0s)0ms ‣

var bytes = btools.write('f', [0]);
var num = btools.read('f', bytes);
assert.deepEqual([0], num);

should turn 1 32-bit float to 4 bytes and back (1)0ms ‣

var bytes = btools.write('f', [1]);
var num = btools.read('f', bytes);
assert.deepEqual([1], num);

should turn 1 32-bit float to 4 bytes and back (0.1234567)0ms ‣

var bytes = btools.write('f', [0.1234567]);
var num = btools.read('f', bytes);
assert.deepEqual('0.1234567', num[0].toFixed(7));

should turn 1 32-bit unsigned int to 4 bytes and back (0s)0ms ‣

var bytes = btools.write('L', [0]);
var num = btools.read('L', bytes);
assert.deepEqual([0], num);

should turn 1 32-bit unsigned int to 4 bytes and back (4294967295)0ms ‣

var bytes = btools.write('L', [4294967295]);
var num = btools.read('L', bytes);
assert.deepEqual([255,255,255,255], bytes);
assert.deepEqual([4294967295], num);

should turn 1 32-bit unsigned int to 4 bytes and back (300)0ms ‣

var bytes = btools.write('L', [300]);
var num = btools.read('L', bytes);
assert.deepEqual([44,1,0,0], bytes);
assert.deepEqual([300], num);

should turn 1 32-bit unsigned int to 4 byte and back (1)0ms ‣

var bytes = btools.write('L', [1]);
var num = btools.read('L', bytes);
assert.deepEqual([1,0,0,0], bytes);
assert.deepEqual([1], num);

should turn 1 32-bit signed int to 4 bytes and back (0s)0ms ‣

var bytes = btools.write('l', [0]);
var num = btools.read('l', bytes);
assert.deepEqual([0], num);

should turn 2 32-bit signed int to 8 bytes and back (-2147483648, 2147483647)0ms ‣

var bytes = btools.write('l', [-2147483648, 2147483647]);
var num = btools.read('l', bytes);
assert.deepEqual([0,0,0,128, 255,255,255,127], bytes);
assert.deepEqual([-2147483648, 2147483647], num);

should turn 2 32-bit signed int to 8 bytes and back (-2147483648, 2147483647)0ms ‣

var bytes = btools.write('l', [-2147483648, 2147483647]);
assert.deepEqual([0,0,0,128, 255,255,255,127], bytes);
var num = btools.read('l', bytes);
assert.deepEqual([-2147483648, 2147483647], num);

should turn 2 32-bit signed int to 8 bytes and back (-2147483647, 2147483647)0ms ‣

var bytes = btools.write('l', [-2147483647, 2147483647]);
assert.deepEqual([1,0,0,128, 255,255,255,127], bytes);
var num = btools.read('l', bytes);
assert.deepEqual([-2147483647, 2147483647], num);

should turn 2 32-bit signed int to 8 bytes and back (-2147483646, 2147483647)0ms ‣

var bytes = btools.write('l', [-2147483646, 2147483647]);
assert.deepEqual([2,0,0,128, 255,255,255,127], bytes);
var num = btools.read('l', bytes);
assert.deepEqual([-2147483646, 2147483647], num);

should turn 2 32-bit signed int to 8 bytes and back (-1, 2147483647)0ms ‣

var bytes = btools.write('l', [-1, 2147483647]);
//assert.deepEqual([2,0,0,128, 255,255,255,127], bytes);
var num = btools.read('l', bytes);
assert.deepEqual([-1, 2147483647], num);

should turn 2 32-bit signed int to 8 bytes and back (-2, 2147483647)0ms ‣

var bytes = btools.write('l', [-2, 2147483647]);
//assert.deepEqual([2,0,0,128, 255,255,255,127], bytes);
var num = btools.read('l', bytes);
assert.deepEqual([-2, 2147483647], num);

should turn 1 32-bit signed int to 4 bytes and back (1)0ms ‣

var bytes = btools.write('l', [1]);
var num = btools.read('l', bytes);
assert.deepEqual([1], num);

should turn 1 24-bit unsigned int to 3 bytes and back (0s)0ms ‣

var bytes = btools.write('T', [0]);
var num = btools.read('T', bytes);
assert.deepEqual([0], num);

should turn 1 24-bit unsigned int to 3 bytes and back (16777215)0ms ‣

var bytes = btools.write('T', [16777215]);
var num = btools.read('T', bytes);
assert.deepEqual([16777215], num);

should turn 1 24-bit unsigned int to 3 byte and back (1)0ms ‣

var bytes = btools.write('T', [1]);
var num = btools.read('T', bytes);
assert.deepEqual([1], num);

should turn 1 24-bit signed int to 3 bytes and back (0s)0ms ‣

var bytes = btools.write('t', [0]);
var num = btools.read('t', bytes);
assert.deepEqual([0], num);

should turn 2 24-bit signed int to 6 bytes and back (-8388608, 8388607)0ms ‣

var bytes = btools.write('t', [-8388608, 8388607]);
var num = btools.read('t', bytes);
assert.deepEqual([-8388608, 8388607], num);

should turn 2 24-bit signed int to 6 bytes and back (-8388607, 8388607)0ms ‣

var bytes = btools.write('t', [-8388607, 8388607]);
var num = btools.read('t', bytes);
assert.deepEqual([-8388607, 8388607], num);

should turn 2 24-bit signed int to 6 bytes and back (-8388607, 8388607)0ms ‣

var bytes = btools.write('t', [-8388606, 8388607]);
var num = btools.read('t', bytes);
assert.deepEqual([-8388606, 8388607], num);

should turn 2 24-bit signed int to 6 bytes and back (-1, 8388607)1ms ‣

var bytes = btools.write('t', [-1, 8388607]);
var num = btools.read('t', bytes);
assert.deepEqual([-1, 8388607], num);

should turn 1 24-bit signed int to 3 byte and back (1)0ms ‣

var bytes = btools.write('t', [1]);
var num = btools.read('t', bytes);
assert.deepEqual([1], num);

should turn 1 16-bit unsigned int to 2 bytes and back (0s)0ms ‣

var bytes = btools.write('H', [0]);
var num = btools.read('H', bytes);
assert.deepEqual([0], num);

should turn 1 16-bit unsigned int to 2 bytes and back (65535)0ms ‣

var bytes = btools.write('H', [65535]);
var num = btools.read('H', bytes);
assert.deepEqual([65535], num);

should turn 1 16-bit unsigned int to 2 byte and back (1)0ms ‣

var bytes = btools.write('H', [1]);
var num = btools.read('H', bytes);
assert.deepEqual([1], num);

should turn 1 16-bit signed int to 2 bytes and back (0s)0ms ‣

var bytes = btools.write('h', [0]);
var num = btools.read('h', bytes);
assert.deepEqual([0], num);

should turn 2 16-bit signed int to 4 bytes and back (-32768, 32767)1ms ‣

var bytes = btools.write('h', [-32768, 32767]);
var num = btools.read('h', bytes);
assert.deepEqual([-32768, 32767], num);

should turn 2 16-bit signed int to 4 bytes and back (-32767, 32767)0ms ‣

var bytes = btools.write('h', [-32767, 32767]);
var num = btools.read('h', bytes);
assert.deepEqual([-32767, 32767], num);

should turn 2 16-bit signed int to 4 bytes and back (-32766, 32767)1ms ‣

var bytes = btools.write('h', [-32766, 32767]);
var num = btools.read('h', bytes);
assert.deepEqual([-32766, 32767], num);

should turn 2 16-bit signed int to 4 bytes and back (-1, 32767)0ms ‣

var bytes = btools.write('h', [-1, 32767]);
var num = btools.read('h', bytes);
assert.deepEqual([-1, 32767], num);

should turn 2 16-bit signed int to 4 bytes and back (-2, 32767)1ms ‣

var bytes = btools.write('h', [-2, 32767]);
var num = btools.read('h', bytes);
assert.deepEqual([-2, 32767], num);

should turn 1 16-bit signed int to 2 byte and back (1)0ms ‣

var bytes = btools.write('h', [1]);
var num = btools.read('h', bytes);
assert.deepEqual([1], num);

should turn 1 16-bit float to 2 byte and back (0.0006)1ms ‣

var bytes = btools.write('e', [0.0006]);
var num = btools.read('e', bytes);
assert.deepEqual('0.0006', num[0].toFixed(4));

should turn 1 16-bit float to 2 byte and back (-0.0006)0ms ‣

var bytes = btools.write('e', [-0.0006]);
var num = btools.read('e', bytes);
assert.deepEqual('-0.0006', num[0].toFixed(4));

should turn 1 16-bit float to 2 byte and back (0.0106)1ms ‣

var bytes = btools.write('e', [0.0106]);
var num = btools.read('e', bytes);
assert.deepEqual('0.0106', num[0].toFixed(4));

should turn 1 16-bit float to 2 byte and back (-0.1006)0ms ‣

var bytes = btools.write('e', [-0.1006]);
var num = btools.read('e', bytes);
assert.deepEqual('-0.1006', num[0].toFixed(4));

should turn 1 16-bit float to 2 byte and back (0.00106)0ms ‣

var bytes = btools.write('e', [0.00106]);
var num = btools.read('e', bytes);
assert.deepEqual('0.00106', num[0].toFixed(5));

should turn 1 16-bit float to 2 byte and back (-0.01006)0ms ‣

var bytes = btools.write('e', [-0.01006]);
var num = btools.read('e', bytes);
assert.deepEqual('-0.01006', num[0].toFixed(5));

should turn 1 16-bit float to 2 byte and back (-0.01006 vs -0.01005)0ms ‣

var bytes = btools.write('e', [-0.01006]);
var num = btools.read('e', bytes);
assert.ok('-0.01005' != num[0].toFixed(5));

should turn 1 8-bit unsigned int to 1 byte and back (0s)1ms ‣

var bytes = btools.write('B', [0]);
var num = btools.read('B', bytes);
assert.deepEqual([0], num);

should turn 1 8-bit unsigned int to 1 byte and back (max)0ms ‣

var bytes = btools.write('B', [255]);
var num = btools.read('B', bytes);
assert.deepEqual([255], num);

should turn 1 8-bit unsigned int to 1 byte and back (1)1ms ‣

var bytes = btools.write('B', [1]);
var num = btools.read('B', bytes);
assert.deepEqual([1], num);

should turn 2 8-bit signed int to 2 bytes (0s)0ms ‣

var bytes = btools.write('b', [0]);
var num = btools.read('b', bytes);
assert.deepEqual([0], num);

should turn 2 8-bit signed int to 2 bytes (-128, 127)0ms ‣

var bytes = btools.write('b', [-128, 127]);
var num = btools.read('b', bytes);
assert.deepEqual([-128, 127], num);

should turn 1 8-bit signed int to 1 byte (-1)0ms ‣

var bytes = btools.write('b', [-1]);
var num = btools.read('b', bytes);
assert.deepEqual([-1], num);

errors when safe=1

Ignores extra bytes for 24-bit values0ms ‣

var buffer = [255,255,255];
assert.deepEqual(
  btools.read('H', buffer, false, 0, buffer.length),
  [65535]);

throws "Bad buffer length" if safe=1 and not enough bytes0ms ‣

var f = function() {
  var buffer = [255];
  btools.read('H', buffer, false, 0, buffer.length);
};
assert.throws(f, /Bad buffer length/);

read empty array0ms ‣

var buffer = [];
var output = btools.read('H', buffer, false, 0, buffer.length);
assert.deepEqual([], output);

structs pack

pack 1000 as h0ms ‣

assert.deepEqual(
  btools.pack('h', 1000),
  [232, 3]);

pack 1000 as <h0ms ‣

assert.deepEqual(
  btools.pack('<h', 1000),
  [232, 3]);

pack [1000] as <h0ms ‣

assert.deepEqual(
  btools.pack('<h', [1000]),
  [232, 3]);

pack 1000 as >h0ms ‣

assert.deepEqual(
  btools.pack('>h', 1000),
  [3, 232]);

pack 1000 as !h0ms ‣

assert.deepEqual(
  btools.pack('!h', 1000),
  [3, 232]);

unpack 1000 as !h0ms ‣

assert.deepEqual(
  btools.unpack('!h', [3, 232]),
  [1000]);

pack [1000] as >h0ms ‣

assert.deepEqual(
  btools.pack('>h', [1000]),
  [3, 232]);

pack [1000, 1] as hh0ms ‣

assert.deepEqual(
  btools.pack('hh', [1000, 1]),
  [232, 3, 1, 0]);

pack [1000, 1] as >hh0ms ‣

assert.deepEqual(
  btools.pack('>hh', [1000, 1]),
  [3, 232, 0, 1]);

pack [1000, 1] as !hh0ms ‣

assert.deepEqual(
  btools.pack('!hh', [1000, 1]),
  [3, 232, 0, 1]);

pack [1000, 1, 1] as >hhl0ms ‣

assert.deepEqual(
  btools.pack('>hhl', [1000, 1, 1]),
  [3, 232, 0, 1, 0, 0, 0, 1]);

pack 0 as B0ms ‣

assert.deepEqual(
  btools.pack('B', 0),
  [0]);

pack 0, 0 as BB0ms ‣

assert.deepEqual(
  btools.pack('BB', [0, 0]),
  [0, 0]);

pack 0, 1 as BB0ms ‣

assert.deepEqual(
  btools.pack('BB', [0, 1]),
  [0, 1]);

pack 0, 1 as >BB0ms ‣

assert.deepEqual(
  btools.pack('>BB', [0, 1]),
  [0, 1]);

pack 0, 1 as <BB0ms ‣

assert.deepEqual(
  btools.pack('<BB', [0, 1]),
  [0, 1]);

pack 0, 1 as >BB0ms ‣

assert.deepEqual(
  btools.pack('>BB', [1, 0]),
  [1, 0]);

pack 0, 0 as HH0ms ‣

assert.deepEqual(
  btools.pack('HH', [0, 0]),
  [0, 0, 0, 0]);

pack 0, 1 as HH0ms ‣

assert.deepEqual(
  btools.pack('HH', [0, 1]),
  [0, 0, 1, 0]);

pack 0, 1 as 2H0ms ‣

assert.deepEqual(
  btools.pack('2H', [0, 1]),
  [0, 0, 1, 0]);

pack 0, 1 as 2B0ms ‣

assert.deepEqual(
  btools.pack('2B', [0, 1]),
  [0, 1]);

pack 0, 1 as >HH0ms ‣

assert.deepEqual(
  btools.pack('>HH', [0, 1]),
  [0, 0, 0, 1]);

pack 0, 1 as >2H0ms ‣

assert.deepEqual(
  btools.pack('>2H', [0, 1]),
  [0, 0, 0, 1]);

pack 0, 1 as <HH0ms ‣

assert.deepEqual(
  btools.pack('<HH', [0, 1]),
  [0, 0, 1, 0]);

pack [0, 0, 0, 0] as BHBH0ms ‣

assert.deepEqual(
  btools.pack('BHBH', [0, 0, 0, 0]),
  [0, 0, 0, 0, 0, 0]);

pack [200, 1, 255, 1] as BHBH0ms ‣

assert.deepEqual(
  btools.pack('BHBH', [200, 1, 255, 1]),
  [200, 1, 0, 255, 1, 0]);

pack [200, 1, 255, 1] as >BHBH0ms ‣

assert.deepEqual(
  btools.pack('>BHBH', [200, 1, 255, 1]),
  [200, 0, 1, 255, 0, 1]);

pack [200, 1, 255, 1] as <BHBH0ms ‣

assert.deepEqual(
  btools.pack('<BHBH', [200, 1, 255, 1]),
  [200, 1, 0, 255, 1, 0]);

pack [200, 1, 255, 1, 1] as <BHBHH0ms ‣

assert.deepEqual(
  btools.pack('<BHBHH', [200, 1, 255, 1, 1]),
  [200, 1, 0, 255, 1, 0, 1, 0]);

pack [200, 1, 255, 1, 1] as <BHB2H0ms ‣

assert.deepEqual(
  btools.pack('<BHB2H', [200, 1, 255, 1, 1]),
  [200, 1, 0, 255, 1, 0, 1, 0]);

pack [200, 1, 255, 1, 1] as <BHBHHB0ms ‣

assert.deepEqual(
  btools.pack('<BHBHHB', [200, 1, 255, 1, 1, 1]),
  [200, 1, 0, 255, 1, 0, 1, 0, 1]);

pack [200, 1, 255, 1, 1] as <BHB2HB1ms ‣

assert.deepEqual(
  btools.pack('<BHB2HB', [200, 1, 255, 1, 1, 1]),
  [200, 1, 0, 255, 1, 0, 1, 0, 1]);

structs unpack

pack 0, 0 as BB0ms ‣

assert.deepEqual(
  btools.unpack('BB', [0, 0]),
  [0, 0]);

pack 0, 1 as BB0ms ‣

assert.deepEqual(
  btools.unpack('BB', [0, 1]),
  [0, 1]);

pack 0, 1 as >BB0ms ‣

assert.deepEqual(
  btools.unpack('>BB', [0, 1]),
  [0, 1]);

pack 0, 1 as <BB0ms ‣

assert.deepEqual(
  btools.unpack('<BB', [0, 1]),
  [0, 1]);

pack 0, 1 as >BB0ms ‣

assert.deepEqual(
  btools.unpack('>BB', [1, 0]),
  [1, 0]);

pack 0, 0 as HH0ms ‣

assert.deepEqual(
  btools.unpack('HH', [0, 0, 0, 0]),
  [0, 0]);

pack 0, 1 as HH0ms ‣

assert.deepEqual(
  btools.unpack('HH', [0, 0, 1, 0]),
  [0, 1]);

pack 0, 1 as >HH0ms ‣

assert.deepEqual(
  btools.unpack('>HH', [0, 0, 0, 1]),
  [0, 1]);

pack 0, 1 as !HH0ms ‣

assert.deepEqual(
  btools.unpack('!HH', [0, 0, 0, 1]),
  [0, 1]);

pack 0, 1 as !HH!0ms ‣

assert.deepEqual(
  btools.unpack('!HH!', [0, 0, 0, 1]),
  [0, 1]);

pack 0, 1 as <HH0ms ‣

assert.deepEqual(
  btools.unpack('<HH', [0, 0, 1, 0]),
  [0, 1]);

pack 0, 0, as BHBH0ms ‣

assert.deepEqual(
  btools.unpack('BHBH', [0, 0, 0, 0, 0, 0]),
  [0, 0, 0, 0]);

pack 0, 1 as BHBH0ms ‣

assert.deepEqual(
  btools.unpack('BHBH', [200, 1, 0, 255, 1, 0]),
  [200, 1, 255, 1]);

pack 0, 1 as >BHBH0ms ‣

assert.deepEqual(
  btools.unpack('>BHBH', [200, 0, 1, 255, 0, 1]),
  [200, 1, 255, 1]);

pack 0, 1 as <BHBH0ms ‣

assert.deepEqual(
  btools.unpack('<BHBH', [200, 1, 0, 255, 1, 0]),
  [200, 1, 255, 1]);

ASCII characters, initial tests

pack a0ms ‣

assert.deepEqual(
  btools.pack('c', '"'),
  [34]);

pack a1ms ‣

assert.deepEqual(
  btools.pack('c', 'a'),
  [97]);

pack [a]0ms ‣

assert.deepEqual(
  btools.pack('c', ['~']),
  [126]);

pack b0ms ‣

assert.deepEqual(
  btools.pack('c', 'b'),
  [98]);

pack ab0ms ‣

assert.deepEqual(
  btools.pack('cc', ['a','b']),
  [97, 98]);

pack abab0ms ‣

assert.deepEqual(
  btools.pack('2c2c', ['a','b','a','b']),
  [97, 98, 97, 98]);

pack abab0ms ‣

assert.deepEqual(
  btools.pack('cc2c', ['a','b','a','b']),
  [97, 98, 97, 98]);

pack abab0ms ‣

assert.deepEqual(
  btools.pack('2ccc', ['a','b','a','b']),
  [97, 98, 97, 98]);

pack a1b0ms ‣

assert.deepEqual(
  btools.pack('cHc', ['a', 1, 'b']),
  [97, 1, 0, 98]);

pack a1bb0ms ‣

// README example
   assert.deepEqual(
     btools.pack('cH2c', ['a', 1, 'b', 'b']),
     [97, 1, 0, 98, 98]);

packTo a0ms ‣

var buffer = new Array(1);
btools.packTo('c', 'a', buffer);
assert.deepEqual(
  buffer,
  [97]);

packTo b0ms ‣

var buffer = new Array(1);
btools.packTo('c', 'b', buffer);
assert.deepEqual(
  buffer,
  [98]);

packTo ab0ms ‣

var buffer = new Array(2);
btools.packTo('cc', ['a','b'], buffer);
assert.deepEqual(
  buffer,
  [97, 98]);

packTo a1b0ms ‣

var buffer = new Array(4);
btools.packTo('cHc', ['a', 1, 'b'], buffer);
assert.deepEqual(
  buffer,
  [97, 1, 0, 98]);

packTo a0ms ‣

var buffer = new Uint8Array(1);
btools.packTo('c', 'a', buffer);
assert.deepEqual(
  buffer,
  new Uint8Array([97]));

packTo b0ms ‣

var buffer = new Uint8Array(1);
btools.packTo('c', 'b', buffer);
assert.deepEqual(
  buffer,
  new Uint8Array([98]));

packTo ab0ms ‣

var buffer = new Uint8Array(2);
btools.packTo('cc', ['a','b'], buffer);
assert.deepEqual(
  buffer,
  new Uint8Array([97, 98]));

packTo a1b0ms ‣

var buffer = new Uint8Array(4);
btools.packTo('cHc', ['a', 1, 'b'], buffer);
assert.deepEqual(
  buffer,
  new Uint8Array([97, 1, 0, 98]));

pack a0ms ‣

assert.deepEqual(
  btools.write('c', 'a'),
  [97]);

pack b0ms ‣

assert.deepEqual(
  btools.write('c', 'b'),
  [98]);

pack ab1ms ‣

assert.deepEqual(
  btools.write('c', ['a','b']),
  [97, 98]);

pack a1b0ms ‣

assert.deepEqual(
  btools.write('c', ['a', '1', 'b']),
  [97, 49, 98]);

writeTo a0ms ‣

var buffer = new Array(1);
btools.writeTo('c', 'a', buffer);
assert.deepEqual(
  buffer,
  [97]);

writeTo b0ms ‣

var buffer = new Array(1);
btools.writeTo('c', 'b', buffer);
assert.deepEqual(
  buffer,
  [98]);

writeTo ab0ms ‣

var buffer = new Array(2);
btools.writeTo('c', ['a','b'], buffer);
assert.deepEqual(
  buffer,
  [97, 98]);

writeTo a1b1ms ‣

var buffer = new Array(3);
btools.writeTo('c', ['a', '1', 'b'], buffer);
assert.deepEqual(
  buffer,
  [97, 49, 98]);

pack "0ms ‣

assert.deepEqual(
  btools.unpack('c', [34]),
  ['"']);

unpack a0ms ‣

assert.deepEqual(
  btools.unpack('c', [97]),
  ['a']);

unpack b0ms ‣

assert.deepEqual(
  btools.unpack('c', [98]),
  ['b']);

unpack ab0ms ‣

assert.deepEqual(
  btools.unpack('cc', [97, 98]),
  ['a', 'b']);

unpack ab0ms ‣

assert.deepEqual(
  btools.unpack('cHc', [97, 1, 0, 98]),
  ['a', 1, 'b']);

read a0ms ‣

assert.deepEqual(
  btools.read('c', [97]),
  ['a']);

read b0ms ‣

assert.deepEqual(
  btools.read('c', [98]),
  ['b']);

read ab1ms ‣

assert.deepEqual(
  btools.read('cc', [97, 98]),
  ['a', 'b']);

read ab0ms ‣

assert.deepEqual(
  btools.read('cHc', [97, 49, 98]),
  ['a', '1', 'b']);

unpackTo a0ms ‣

var buffer = new Array(1);
btools.unpackTo('c', [97], buffer);
assert.deepEqual(
  buffer,
  ['a']);

unpackTo b0ms ‣

var buffer = new Array(1);
btools.unpackTo('c', [98], buffer);
assert.deepEqual(
  buffer,
  ['b']);

unpackTo ab0ms ‣

var buffer = new Array(2);
btools.unpackTo('cc', [97, 98], buffer);
assert.deepEqual(
  buffer,
  ['a', 'b']);

unpackTo a1b0ms ‣

var buffer = new Array(3);
btools.unpackTo('cHc', [97, 1, 0, 98], buffer);
assert.deepEqual(
  buffer,
  ['a', 1, 'b']);

readTo a0ms ‣

var buffer = new Array(1);
btools.readTo('c', [97], buffer);
assert.deepEqual(
  buffer,
  ['a']);

readTo b0ms ‣

var buffer = new Array(1);
btools.readTo('c', [98], buffer);
assert.deepEqual(
  buffer,
  ['b']);

readTo ab0ms ‣

var buffer = new Array(2);
btools.readTo('c', [97, 98], buffer);
assert.deepEqual(
  buffer,
  ['a', 'b']);

readTo a1b0ms ‣

var buffer = new Array(3);
btools.readTo('c', [97, 49, 98], buffer);
assert.deepEqual(
  buffer,
  ['a', '1', 'b']);

ASCII characters, exceptions

TypeError on pack number 10ms ‣

var a = function() {
  btools.pack('c', 1);
};
//assert.throws(a, /index 0 \(1\)/);
assert.throws(a, /1/);

TypeError on pack {}1ms ‣

var a = function() {
  btools.pack('C', {});
};
//assert.throws(a, /index 0 \(\[object Object]\)/);
assert.throws(a, /\[object Object\]/);

TypeError on pack c aa0ms ‣

var a = function() {
  btools.pack('c', ['aa']);
};
//assert.throws(a, /index 0 \(aa\)/);
assert.throws(a, /aa/);

TypeError on pack cc aa, c0ms ‣

var a = function() {
  btools.pack('cc', ['aa', 'c']);
};
//assert.throws(a, /index 0 \(aa\)/);
assert.throws(a, /aa/);

TypeError on pack cc aa2ms ‣

var a = function() {
  btools.pack('cc', ['aa']);
};
assert.throws(a, /Number of values do not match the format/);

TypeError on pack Unicode char0ms ‣

var a = function() {
  btools.pack('1c', '');
};
//assert.throws(a, /index 0 \(\)/);
assert.throws(a, //);

TypeError on unpack ISO-8859-1 char0ms ‣

var a = function() {
  console.log(btools.unpack('c', [255])); //ÿ
};
//assert.throws(a, /index 0 \(ÿ\)/);
assert.throws(a, /ÿ/);

TypeError on unpack ISO-8859-1 char0ms ‣

var a = function() {
  console.log(btools.unpack('c', [128]));
};
//assert.throws(a, /index 0 \(\x80\)/);
assert.throws(a, /\x80/);

TypeError on pack ISO-8859-1 char0ms ‣

var a = function() {
  console.log(btools.pack('c', '¡'));
};
//assert.throws(a, /index 0 \(¡\)/);
assert.throws(a, /¡/);

TypeError on pack ISO-8859-1 char0ms ‣

var a = function() {
  console.log(btools.pack('c', 'ÿ'));
};
//assert.throws(a, /index 0 \(ÿ\)/);
assert.throws(a, /ÿ/);

TypeError on pack UTF char1ms ‣

var a = function() {
  console.log(btools.pack('c', '輸'));
};
//assert.throws(a, /index 0 \(輸\)/);
assert.throws(a, /輸/);

bfloat16 numbers - wikipedia examples

pack 10ms ‣

assert.deepEqual(
  btools.pack('g', 1),
  [0x80,0x3f]);

unpack 10ms ‣

assert.deepEqual(
  btools.unpack('g', [0x80,0x3f])[0], 
  1);

pack -20ms ‣

assert.deepEqual(
  btools.pack('g', -2), 
  [0x00,0xc0]);

unpack -20ms ‣

assert.deepEqual(
  btools.unpack('g', [0x00,0xc0])[0], 
  -2);

unpack -2 BE0ms ‣

assert.deepEqual(
  btools.unpack('>g', [0xc0,0x00])[0], 
  -2);

unpack -2 BE0ms ‣

assert.deepEqual(
  btools.unpack('!g', [0xc0,0x00])[0], 
  -2);

pack pi0ms ‣

assert.deepEqual(
  btools.pack('g', 3.140625), 
  [0x49,0x40]);

unpack pi1ms ‣

assert.deepEqual(
  btools.unpack('g', [0x49,0x40])[0], 
  3.140625);

pack 1/30ms ‣

assert.deepEqual(
  btools.pack('g', 0.333984375), 
  [0xab,0x3e]);

unpack 1/31ms ‣

assert.deepEqual(
  btools.unpack('g', [0xab,0x3e])[0], 
  0.333984375);

pack 00ms ‣

assert.deepEqual(
  btools.pack('g', 0), 
  [0x00,0x00]);

unpack 00ms ‣

assert.deepEqual(
  btools.unpack('g', [0x00,0x00])[0], 
  0);

pack -00ms ‣

assert.deepEqual(
  btools.pack('g', -0), 
  [0x00,0x80]);

unpack -00ms ‣

assert.deepEqual(
  btools.unpack('g', [0x00,0x80])[0], 
  -0);

pack Infinity0ms ‣

assert.deepEqual(
  btools.pack('g', Infinity), 
  [0x80,0x7f]);

unpack Infinity0ms ‣

assert.deepEqual(
  btools.unpack('g', [0x80,0x7f])[0], 
  Infinity);

pack -Infinity0ms ‣

assert.deepEqual(
  btools.pack('g', -Infinity), 
  [0x80,0xff]);

unpack -Infinity0ms ‣

assert.deepEqual(
  btools.unpack('g', [0x80,0xff])[0], 
  -Infinity);

pack NaN0ms ‣

assert.deepEqual(
  btools.pack('g', NaN), 
  [0xc1,0xff]);

pack NaN BE0ms ‣

assert.deepEqual(
  btools.pack('>g', NaN), 
  [0xff,0xc1]);

packArray NaN and other numbers0ms ‣

assert.deepEqual(
  btools.write('g', [0,NaN,0]), 
  [0x00,0x00,0xc1,0xff,0x00,0x00]);

packArray NaN BE and other numbers0ms ‣

assert.deepEqual(
  btools.write('>g', [0,NaN,0]), 
  [0x00,0x00,0xff,0xc1,0x00,0x00]);

unpack NaN0ms ‣

assert.ok(isNaN(btools.unpack('g', [0xc1,0xff])));

read NaN and other numbers0ms ‣

// Tests are split to work on older browsers
// where deepEqual will fail to compare NaN in arrays
var result = btools.read(
  'g', [0x00,0x00,0xc1,0xff,0x00,0x00]);
assert.equal(result.length, 3);
assert.equal(result[0], 0);
assert.ok(isNaN(result[1]));
assert.equal(result[2], 0);

unpack NaN BE1ms ‣

assert.ok(isNaN(btools.unpack('>g', [0xff,0xc1])));

read NaN BE and other numbers0ms ‣

// Tests are split to work on older browsers
// where deepEqual will fail to compare NaN in arrays
var result = btools.read(
  '>g', [0x00,0x00,0xff,0xc1,0x00,0x00]);
assert.equal(result.length, 3);
assert.equal(result[0], 0);
assert.ok(isNaN(result[1]));
assert.equal(result[2], 0);

unpack -NaN as NaN0ms ‣

assert.ok(isNaN(btools.unpack('g', [0x81,0xff])));

unpack -NaN BE as NaN0ms ‣

assert.ok(isNaN(btools.unpack('>g', [0xff,0x81])));

unpack -NaN BE as NaN0ms ‣

assert.ok(isNaN(btools.unpack('!g', [0xff,0x81])));

Binary16 numbers

pack 00ms ‣

assert.deepEqual(
	btools.pack('e', 0), 
  [0,0]);

unpack 00ms ‣

assert.equal(
	btools.unpack('e', [0,0])[0], 
  0);

pack -00ms ‣

assert.deepEqual(
	btools.pack('e', -0), 
  [0,128]);

unpack -00ms ‣

assert.equal(
	btools.unpack('e', [0,128])[0], 
  -0);

pack 1e-250ms ‣

assert.deepEqual(
  btools.pack('e', 1e-25), // FIXME
  [0,0]);

unpack 00ms ‣

assert.equal(
  btools.unpack('e', [0,0])[0], 
  0);

pack NaN0ms ‣

assert.deepEqual(
  btools.pack('e', NaN), 
  [0, 126]); // Python struct.pack('e', math.nan)

unpack NaN0ms ‣

assert.ok(isNaN(btools.unpack('e', [0, 126])[0]));

pack Infinity0ms ‣

assert.deepEqual(
	btools.pack('e', Infinity), 
  [0, 124]); // Python struct.pack('e', math.inf)

unpack Infinity0ms ‣

assert.equal(
	btools.unpack('e', [0, 124])[0], 
  Infinity);

pack -Infinity1ms ‣

assert.deepEqual(
	btools.pack('e', -Infinity), 
  [0x00, 0xfc]); // Python struct.pack('e', -math.inf)

unpack -Infinity0ms ‣

assert.equal(
	btools.unpack('e', [0x00, 0xfc])[0], 
    -Infinity);

round 65520 to Infinity when packing0ms ‣

assert.deepEqual(
  btools.pack('e', 65520), 
  [0, 124]);

round 65520+ to Infinity when packing0ms ‣

assert.deepEqual(
  btools.pack('e', 65521), 
  [0, 124]);

pack pi as 3.141590ms ‣

assert.deepEqual(btools.pack('e', 3.14159), 
  [0x48,0x42]); // Python struct.pack('e', 3.14159)

unpack pi as 3.1406250ms ‣

// Use toFixed(6) here to avoid JS rounding differences with Python.
// Python struct.pack is used to check the data in most of the tests
assert.equal(btools.unpack('e', [0x48,0x42])[0].toFixed(6), 
  '3.140625');

pack 10ms ‣

assert.deepEqual(
	btools.pack('e', 1), 
  [0x00,0x3c]);

unpack 10ms ‣

assert.equal(
	btools.unpack('e', [0x00,0x3c])[0], 
  1);

pack -2048 (min exact)0ms ‣

assert.deepEqual(
	btools.pack('e', -2048), 
  [0x00,0xe8]);

unpack -2048 (min exact)0ms ‣

assert.equal(
	btools.unpack('e', [0x00,0xe8])[0], 
  -2048);

pack 2048 (max exact)0ms ‣

assert.deepEqual(
	btools.pack('e', 2048), 
  [0x00,0x68]);

unpack 2048 (max exact)0ms ‣

assert.equal(
	btools.unpack('e', [0x00,0x68])[0], 
  2048);

pack 2049 like it pack 20480ms ‣

assert.deepEqual(
  btools.pack('e', 2049), 
  [0x00,0x68]);

pack 20500ms ‣

assert.deepEqual(
  btools.pack('e', 2050), 
  [0x01,0x68]);

unpack 20500ms ‣

assert.deepEqual(
  btools.unpack('e', [0x01,0x68])[0], 
  2050);

pack 2051 like it pack 20500ms ‣

assert.deepEqual(
  btools.pack('e', 2051), 
  [0x01,0x68]);

pack 1/30ms ‣

assert.deepEqual(
  btools.pack('e', 0.33325),
  [85,53]);

pack -20ms ‣

assert.deepEqual(
  btools.pack('e', -2),
  [0, 192]);

pack 655040ms ‣

assert.deepEqual(
  btools.pack('e', 100),
  [64, 86]);

pack 655040ms ‣

assert.deepEqual(
  btools.pack('e', 500),
  [208, 95]);

pack 655040ms ‣

assert.deepEqual(
  btools.pack('e', 1000),
  [208, 99]);

pack 655041ms ‣

assert.deepEqual(
  btools.pack('e', 10000),
  [226, 112]);

pack 655040ms ‣

assert.deepEqual(
  btools.pack('e', 30000),
  [83, 119]);

pack 655040ms ‣

assert.deepEqual(
  btools.pack('e', 40000),
  [226, 120]);

pack 655040ms ‣

assert.deepEqual(
  btools.pack('e', 65504),
  [255, 123]);

read 00ms ‣

assert.deepEqual(
  btools.read('e', [0, 0]),
  [0]);

read 00ms ‣

assert.deepEqual(
  btools.read('e', [0, 0]),
  [0]);

read 00ms ‣

assert.deepEqual(
  btools.read('e', [0, 0]),
  [0]);

read 00ms ‣

assert.deepEqual(
  btools.read('e', [0,192]),
  [-2]);

read 10ms ‣

assert.deepEqual(
  btools.read('e', [0, 60]),
  [1]);

read 1/31ms ‣

assert.deepEqual(
  btools.read('e', [85, 53])[0].toFixed(5),
  '0.33325');

read 0.000060ms ‣

assert.deepEqual(
  btools.read('e', [0, 4])[0].toFixed(5),
  '0.00006');

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [64, 86])[0],
  100);

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [208, 95])[0],
  500);

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [208, 99])[0],
  1000);

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [226, 112])[0],
  10000);

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [83, 119])[0],
  30000);

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [226, 120])[0],
  40000);

read 655040ms ‣

assert.deepEqual(
  btools.read('e', [255, 123])[0],
  65504);

read [65504, 0.33325]0ms ‣

var halfs = btools.read('e', [208, 95, 85, 53]);
assert.equal(halfs[0], 500);

read [65504, 0.33325]0ms ‣

var halfs = btools.read('e', [208, 95, 85, 53]);
assert.equal(halfs[1].toFixed(5), '0.33325');

read 655040ms ‣

var halfs = btools.read('e', [255, 123]);
assert.equal(halfs[0], 65504);

read [65504, 0.33325, extra byte]0ms ‣

var halfs = btools.read('e', [255, 123, 85, 53,128]);
assert.equal(halfs[1].toFixed(5), '0.33325');

read [65504, 0.33325, extra byte]0ms ‣

var halfs = btools.read('e', [255, 123, 85, 53,128]);
assert.equal(halfs[0], 65504);

read 1/3 BE0ms ‣

assert.deepEqual(
  btools.read('>e', [53, 85])[0].toFixed(5),
  '0.33325');

read 1/3 BE0ms ‣

assert.deepEqual(
  btools.read('!e', [53, 85])[0].toFixed(5),
  '0.33325');

Subnormal 16-bit floating point numbers

pack 0.0000000596046450ms ‣

assert.deepEqual(
  btools.pack('e', 0.000000059604645),
  [1, 0]);

pack 0.0000609755520ms ‣

assert.deepEqual(
  btools.pack('e', 0.000060975552),
  [255, 3]);

Binary32 numbers

pack 00ms ‣

assert.deepEqual(
	btools.pack('f', 0), 
  [0,0,0,0]);

unpack 00ms ‣

assert.equal(
	btools.unpack('f', [0,0,0,0])[0],
  0);

pack -00ms ‣

assert.deepEqual(
	btools.pack('f', [-0]), 
  [0,0,0,128]);

unpack -00ms ‣

assert.equal(
	btools.unpack('f', [0,0,0,128])[0], 
  -0);

pack NaN0ms ‣

assert.deepEqual(
	btools.pack('f', NaN), 
  [0,0,192,127]); // 0 0 0xc0 0x7f

pack -NaN0ms ‣

assert.deepEqual(
  btools.pack('f', -NaN), 
  [0,0,192,127]); // 0 0 0xc0 0x7f

unpack NaN1ms ‣

assert.ok(
  isNaN(btools.unpack('f', [0,0,192,127])[0])); // 0 0 0xc0 0x7f

unpack NaN0ms ‣

assert.ok(isNaN(btools.unpack('f', [0,0,192,255])[0])); // 0 0 0xc0 0x7f

unpack NaN0ms ‣

assert.ok(isNaN(btools.unpack('f', [0,0,192,127])[0]));

unpack -NaN0ms ‣

var possibleNegativeNaN = btools.unpack('f', [0x01,0x00,0x80,0xff])[0];
assert.ok(isNaN(possibleNegativeNaN));

unpack NaN, stuff on the significand0ms ‣

assert.ok(isNaN(btools.unpack('f', [0,1,192,127])));

unpack NaN, more stuff on the significand0ms ‣

assert.ok(isNaN(btools.unpack('f', [0,127,192,127])));

unpack -NaN0ms ‣

var possibleNegativeNaN = btools.unpack('f', [0x01,0x00,0x80,0xff])[0];
assert.ok(isNaN(possibleNegativeNaN));

unpack -NaN, stuff on the significand0ms ‣

var possibleNegativeNaN = btools.unpack('f', [0x01,0x01,0x80,0xff])[0];
assert.ok(isNaN(possibleNegativeNaN));

unpack -NaN, more stuff on the significand0ms ‣

var possibleNegativeNaN = btools.unpack('f', [0x01,0xcf,0x80,0xff])[0];
assert.ok(isNaN(possibleNegativeNaN));

pack Infinity0ms ‣

assert.deepEqual(
	btools.pack('f', Infinity), 
  [0x00,0x00,0x80,0x7f]); // 0x80 0xff 128 127

unpack Infinity0ms ‣

assert.equal(
	btools.unpack('f', [0x00,0x00,0x80,0x7f])[0], 
  Infinity); // 0x80 0xff 128 127

pack -Infinity0ms ‣

assert.deepEqual(
	btools.pack('f', -Infinity), 
  [0x00,0x00,0x80,0xff]); // 0x80 0xff 128 255

unpack -Infinity0ms ‣

assert.equal(
	btools.unpack('f', [0x00,0x00,0x80,0xff])[0], 
  -Infinity); // 0x80 0xff 128 255

pack pi as 3.14159274100ms ‣

assert.deepEqual(
  btools.pack('f', 3.1415927410), 
  [0xdb,0x0F,0x49,0x40]);

unpack pi as 3.14159274100ms ‣

assert.equal(
  btools.unpack('f', [0xdb,0x0F,0x49,0x40])[0].toFixed(10), 
  '3.1415927410');

pack 11ms ‣

assert.deepEqual(
	btools.pack('f', 1), 
  [0x00,0x00,0x80,0x3f]);

unpack 10ms ‣

assert.equal(
	btools.unpack('f', [0x00,0x00,0x80,0x3f])[0], 
  1);

pack 1 BE0ms ‣

assert.deepEqual(
  btools.pack('>f', 1), 
  [0x3f,0x80,0x00,0x00]);

unpack 1 BE0ms ‣

assert.equal(
  btools.unpack('>f', [0x3f,0x80,0x00,0x00])[0], 
  1);

pack -16777216 (min exact)0ms ‣

assert.deepEqual(
	btools.pack('f', -16777216), 
  [0x00,0x00,0x80,0xcb]);

unpack -16777216 (min exact)0ms ‣

assert.equal(
	btools.unpack('f', [0x00,0x00,0x80,0xcb])[0], 
  -16777216);

pack 16777216 (max exact)0ms ‣

assert.deepEqual(
	btools.pack('f', 16777216), 
  [0x00,0x00,0x80,0x4b]);

unpack 16777216 (max exact)0ms ‣

assert.equal(
	btools.unpack('f', [0x00,0x00,0x80,0x4b])[0], 
  16777216);

pack 0.0000000010ms ‣

assert.deepEqual(
  btools.pack('f', 0.000000001), 
  [0x5f,0x70,0x89,0x30]);

unpack 0.0000000011ms ‣

assert.deepEqual(
	btools.unpack('f', [0x5f,0x70,0x89,0x30])[0].toFixed(9),
    '0.000000001');

pack -0.0000000010ms ‣

assert.deepEqual(
  btools.pack('f', -0.000000001), 
  [0x5f,0x70,0x89,0xb0]);

unpack -0.0000000010ms ‣

assert.equal(
	btools.unpack('f', [0x5f,0x70,0x89,0xb0])[0].toFixed(9),
    '-0.000000001');

pack 214748364.70ms ‣

// struct.pack('f', 214748364.7) == '\xcd\xcc\x4c\x4d'
assert.deepEqual(
  btools.pack('f', 214748364.7), 
  [205,204,76,77]);

unpack 214748364.70ms ‣

// struct.unpack('f', b'\xcd\xcc\x4c\x4d') == 214748368.0
assert.deepEqual(
  btools.unpack('f', [205,204,76,77])[0].toFixed(1), 
  '214748368.0');

pack 21474.836470ms ‣

// struct.pack('f', 21474.83647) == '\xac\xc5\xa7\x46'
assert.deepEqual(
  btools.pack('f', 21474.83647), 
  [0xac,0xc5,0xa7,0x46]);

unpack 21474.836470ms ‣

// struct.unpack('f', b'\xac\xc5\xa7\x46') == 21474.8359375
assert.deepEqual(
  btools.unpack('f', [0xac,0xc5,0xa7,0x46])[0].toFixed(7),
  '21474.8359375');

pack 214.74836470ms ‣

// struct.pack('f', 214.7483647) == b'\x95\xbf\x56\x43'
assert.deepEqual(
  btools.pack('f', 214.7483647), 
  [0x95,0xbf,0x56,0x43]);

unpack 214.74836470ms ‣

// struct.unpack('f', b'\x95\xbf\x56\x43') == 214.7483673095703
assert.deepEqual(
  btools.unpack('f', [0x95,0xbf,0x56,0x43])[0].toFixed(13), 
  '214.7483673095703');

should turn 4 bytes hex to 1 32-bit float0ms ‣

assert.deepEqual(
  btools.read('f', [95,112,9,64])[0].toFixed(7),
  '2.1474836');

pack 0.90ms ‣

assert.deepEqual(
  btools.pack('f', 0.9), 
  [0x66,0x66,0x66,0x3f]);

unpack 0.90ms ‣

assert.deepEqual(
  btools.unpack('f', [0x66,0x66,0x66,0x3f])[0].toFixed(1), 
  '0.9');

should turn 8 bytes to 2 32-bit floats0ms ‣

assert.deepEqual(
  btools.read('f', [0,0,0,0,0,0,0,0]),
  [0,0]);

should turn 1 32-bit float from 4 bytes BE hex (2.1474836)0ms ‣

assert.deepEqual(
  btools.read('>f', [64,9,112,95])[0].toFixed(7),
  '2.1474836');

should turn 1 32-bit float from 4 bytes BE hex (2.1474836)0ms ‣

assert.deepEqual(
  btools.read('!f', [64,9,112,95])[0].toFixed(7),
  '2.1474836');

Subnormal 32-bit floating point numbers

pack 0.000000000000000000000010ms ‣

assert.deepEqual(
  btools.pack('f', 0.00000000000000000000001),
  [154, 109, 65, 25]);

pack 0ms ‣

assert.deepEqual(
  btools.pack('f', -0.0000000000000000000001),
  [1, 201, 241, 154]);

pack 0ms ‣

assert.deepEqual(
  btools.pack('f', 0.0000000000000000000000000000000001),
  [61, 236, 4, 7]);

pack 0ms ‣

assert.deepEqual(
  btools.pack('f', -0.0000000000000000000000000000000001),
  [61, 236, 4, 135]);

pack 0ms ‣

assert.deepEqual(
  btools.pack('f', 0.0000000000000000000000000000000000000000000000000000000000000001),
  [0, 0, 0, 0]);

pack 0ms ‣

assert.deepEqual(
  btools.pack('f', -0.0000000000000000000000000000000000000000000000000000000000000001),
  [0, 0, 0, 128]);

Underflow in 32-bit floating point numbers

pack underflow0ms ‣

assert.deepEqual(
  btools.pack('f', 0.0000000000000000000000000000000000000000000000002),
  [0, 0, 0, 0]);

pack underflow0ms ‣

assert.deepEqual(
  btools.pack('f', -0.0000000000000000000000000000000000000000000000002),
  [0, 0, 0, 128]);

pack underflow0ms ‣

assert.deepEqual(
  btools.pack('f', 0.0000000000000000000000000000000000000000000000003),
  [0, 0, 0, 0]);

pack underflow0ms ‣

assert.deepEqual(
  btools.pack('f', -0.0000000000000000000000000000000000000000000000003),
  [0, 0, 0, 128]);

Binary64 numbers

pack 00ms ‣

assert.deepEqual(
	btools.pack('d', 0), 
  [0,0,0,0,0,0,0,0]);

unpack 00ms ‣

assert.equal(
	btools.unpack('d', [0,0,0,0,0,0,0,0])[0], 
  0);

pack -00ms ‣

assert.deepEqual(
	btools.pack('d', -0), 
  [0,0,0,0,0,0,0,128]);

unpack -00ms ‣

assert.equal(
	btools.unpack('d', [0,0,0,0,0,0,0,128])[0], 
  -0);

pack NaN0ms ‣

assert.deepEqual(
  btools.pack('d', NaN), 
  [0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x7f]);

pack NaN0ms ‣

assert.deepEqual(
  btools.pack('d', -NaN), 
  [0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x7f]);

unpack NaN (quiet)0ms ‣

assert.ok(isNaN(btools.unpack('d', 
  [0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x7f])[0]));

unpack NaN (signaling)0ms ‣

assert.ok(isNaN(btools.unpack('d', 
  [0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f])[0]));

unpack NaN (signaling)0ms ‣

assert.ok(isNaN(btools.unpack('d', 
  [0xff,0xff,0xff,0xff,0xff,0xff,0xf8,0xff])[0]));

pack Infinity0ms ‣

// Python struct.pack('d', math.inf)
assert.deepEqual(
	btools.pack('d', Infinity), 
  [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x7f]);

unpack Infinity0ms ‣

assert.equal(
	btools.unpack('d', [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x7f])[0], 
  Infinity);

pack -Infinity0ms ‣

// Python struct.pack('d', -math.inf)
assert.deepEqual(
	btools.pack('d', -Infinity), 
  [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xff]);

unpack -Infinity0ms ‣

assert.equal(
	btools.unpack('d', [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xff])[0], 
  -Infinity);

pack pi as 3.14159265358979310ms ‣

assert.deepEqual(
  btools.pack('d', 3.1415926535897931), 
  [0x18,0x2d,0x44,0x54,0xfb,0x21,0x09,0x40]);

unpack pi as 3.14159265358979310ms ‣

assert.equal(
  btools.unpack('d', [0x18,0x2d,0x44,0x54,0xfb,0x21,0x09,0x40])[0].toFixed(15), 
  '3.141592653589793');

pack 1e-250ms ‣

var r = btools.pack('d', 1e-25);
// older JS engines may show some rounding differences;
// this should not be considered an error
var p1 = [218,125,218,245,208,242,190,58];
var p2 = [217,125,218,245,208,242,190,58];
assert.ok(r.toString() == p1.toString() || r.toString() == p2.toString());

unpack 1e-250ms ‣

assert.equal(
  btools.unpack('d', [0xd9,0x7d,0xda,0xf5,0xd0,0xf2,0xbe,0x3a])[0],
  1e-25);

pack -10ms ‣

assert.deepEqual(
  btools.pack('d', -1),
  [0,0,0,0,0,0,240,191]);

pack -0.50ms ‣

assert.deepEqual(
  btools.pack('d', -0.5),
  [0,0,0,0,0,0,224,191]);

pack 0.50ms ‣

assert.deepEqual(
  btools.pack('d', 0.5),
  [0,0,0,0,0,0,224,63]);

pack 3.1415926535897930ms ‣

assert.deepEqual(
  btools.pack('d', 3.141592653589793),
  [24,45,68,84,251,33,9,64]);

pack 90ms ‣

assert.deepEqual(
  btools.pack('d', 9),
  [0,0,0,0,0,0,34,64]);

pack 31.415926535897930ms ‣

assert.deepEqual(
  btools.pack('d', 31.41592653589793),
  [94,56,85,41,122,106,63,64]);

pack 314159265358979.30ms ‣

// struct.pack() == b'\x35\x48\xa2\x76\x9e\xdb\xf1\x42'
var r = btools.pack('d', 314159265358979.3);
// Old JS engines like the one in IE may show some rounding differences
// in edge cases with 64-bit floating point numbers;
// This software returns the same value as any modern programming
// language do (the correct value!), and some tests are edited to
// support both "real" result and the old engine result.
// This should not be considered a problem, as the old engines are
// doing what they propose to do according to their limitations,
// and users of those old systems should expect those behaviours.
// This only happen in edge cases, when the exponent or the fraction
// greatly exceeds the precision limit of the type.
var p1 = [53,72,162,118,158,219,241,66];
var p2 = [54,72,162,118,158,219,241,66];
assert.ok(r.toString() == p1.toString() || r.toString() == p2.toString());

unpack 314159265358979.30ms ‣

assert.deepEqual(
  btools.unpack('d', [0x35,0x48,0xa2,0x76,0x9e,0xdb,0xf1,0x42])[0],
  314159265358979.3);

pack 00ms ‣

assert.deepEqual(
  btools.pack('d', 0, 16),
  [0,0,0,0,0,0,0,0]);

pack 20ms ‣

assert.deepEqual(
  btools.pack('d', 2, 16),
  [0,0,0,0,0,0,0,64]);

packArray [0, 0, 1]0ms ‣

assert.deepEqual(
  btools.write('d', [0, 0, 1]),
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240,63]);

packArray [0, 1, 0]0ms ‣

assert.deepEqual(
  btools.write('d', [0, 1, 0]),
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,240,63,0,0,0,0,0,0,0,0]);

should turn 8 bytes to 1 64-bit float0ms ‣

assert.equal(
  btools.read('d', [75,40,253,58,221,154,191,63])[0],
  0.123456789876543);

Throws bad buffer length error if not enough bytes (type d)0ms ‣

var a = function() {
  btools.read('d', [75,40,253,58,221,154,191]);
};
assert.throws(a, /Bad buffer length/);

should read 8 bytes as a 64-bit float0ms ‣

assert.equal(
  btools.read('d', [0,0,0,0,0,0,0,0])[0],
  0);

should turn 16 bytes to 2 64-bit floats0ms ‣

assert.equal(
  btools.read('d', [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])[0],
  0);
assert.equal(
  btools.read('d', [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])[1],
  0);

should turn 8 bytes bin to 1 64-bit float0ms ‣

assert.equal(
  btools.read('d', [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])[0],
  0);

should turn 8 bytes bin to 1 64-bit float0ms ‣

assert.equal(
  btools.read(
    'd',
    [
      75,
      40,
      253,
      58,
      221,
      154,
      191,
      63
    ])[0].toFixed(15),
  '0.123456789876543');

should turn 8 bytes to 1 64-bit float (31.41592653589793)0ms ‣

assert.deepEqual(
  btools.read('d', [94,56,85,41,122,106,63,64]),
  [31.41592653589793]);

should turn 8 bytes to 1 64-bit float (314159265358979.3)0ms ‣

assert.deepEqual(
  btools.read('d', [53,72,162,118,158,219,241,66]),
  [314159265358979.3]);

should turn 8 bytes hex to 1 64-bit float (2)0ms ‣

assert.deepEqual(
  btools.read('d', [0,0,0,0,0,0,0,64]),
  [2]);

should turn 1 signed 32-bit float to 4 bytes (1)0ms ‣

assert.deepEqual(
  btools.read('d', [0,0,0,0,0x00,0x00,0xf0,0x7f]), 
  [Infinity]); // 240 127 0xf0 0x7f

should turn 1 signed 32-bit float to 4 bytes (1)0ms ‣

assert.deepEqual(
  btools.read('d', [0,0,0,0,0x00,0x00,0xf0,0xff]), 
  [-Infinity]); // 240 127 0xf0 0x7f

should turn 1 signed 32-bit float to 4 bytes (1)0ms ‣

assert.ok(isNaN(
  btools.read(
    'd',
    [0,0,0,0,0,0,248,127]))); // 248 127 0xf8 0x7f

should turn 1 64-bit float to 8 bytes BE (pi)0ms ‣

assert.deepEqual(
  btools.read('>d', [64, 9, 33, 251, 84, 68, 45, 24]),
  [3.141592653589793]);

should turn 1 64-bit float to 8 bytes BE (pi)0ms ‣

assert.deepEqual(
  btools.read('!d', [64, 9, 33, 251, 84, 68, 45, 24]),
  [3.141592653589793]);

Subnormal 64-bit floating point numbers

pack 0.000000000000000000000010ms ‣

assert.deepEqual(
  btools.pack('d', 0.0000000000000000000000000000000000000000000000000001),
  [112, 15, 218, 88, 252, 39, 35, 53]);

unpack 0.000000000000000000000010ms ‣

assert.deepEqual(
  btools.unpack('d', [112, 15, 218, 88, 252, 39, 35, 53]),
  [1e-52]);

pack 0ms ‣

assert.deepEqual(
  btools.pack('d', -0.0000000000000000000000000000000000000000000000000001),
  [112, 15, 218, 88, 252, 39, 35, 181]);

unpack 0ms ‣

assert.deepEqual(
  btools.unpack('d', [112, 15, 218, 88, 252, 39, 35, 181]),
  [-1e-52]);

pack pi as 3.14159265358979311ms ‣

unpack pi as 3.14159265358979310ms ‣

pack pi as 3.14159274100ms ‣

unpack pi as 3.14159274100ms ‣

pack true uInt16 (1, 0) should raise a NaN error0ms ‣

pack false uInt16 (0, 0) should raise a NaN error0ms ‣

pack uInt16 (65535, 16)0ms ‣

pack float32 (2.1474836, 16)0ms ‣

pack uInt8 (254)0ms ‣

pack uInt8 (255)0ms ‣

pack int8 (-1)0ms ‣

pack int8 (-2)0ms ‣

throws a TypeError if packString value is a number0ms ‣

unpack uInt160ms ‣

unpack float160ms ‣

unpack uInt160ms ‣

packArray uInt160ms ‣

packArray int320ms ‣

packArray float320ms ‣

should ignore repeat count numbers on write()0ms ‣

should ignore repeat count numbers on write()0ms ‣

read uInt160ms ‣

should ignore repeat count numbers on read()0ms ‣

should ignore repeat count numbers on read()0ms ‣

read float640ms ‣

Ignores extra bytes for 32-bit values0ms ‣

Ignores extra bytes for 24-bit values0ms ‣

throws errors with correct index when packing0ms ‣

thows error if packing something other than Number, Boolean or null0ms ‣

undefined value0ms ‣

null value0ms ‣

string value0ms ‣

undefined value, index 10ms ‣

Infinity value, index 10ms ‣

-Infinity value, index 10ms ‣

NaN value, index 10ms ‣

char, index 10ms ‣

thows error if packing something other than Number or Boolean (float)1ms ‣

undefined value0ms ‣

null value0ms ‣

string value0ms ‣

undefined value, index 10ms ‣

char, index 10ms ‣

Bad buffer length on unpack, missing a byte, safe mode0ms ‣

Bad buffer length on unpack, zero bytes, safe mode0ms ‣

8-bit overflow, positive0ms ‣

8-bit overflow, negative0ms ‣

8-bit overflow, negative, index 20ms ‣

type is a empty array1ms ‣

type is a empty object0ms ‣

pack type is a number0ms ‣

unpack type is a number0ms ‣

write type is a number0ms ‣

read type is a number0ms ‣

writeTo type is a number0ms ‣

readTo type is a number1ms ‣

-1bit)0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index1ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣

Check the index0ms ‣

Check the packed 16-bit values0ms ‣