@songtonyli/dsh-cli 0.1.11 → 0.1.13

package/node_modules/restructure/test/Number.js

@@ -0,0 +1,356 @@
+import {
+  uint8,
+  uint16, uint16be, uint16le,
+  uint24, uint24be, uint24le,
+  uint32, uint32be, uint32le,
+  int8,
+  int16, int16be, int16le,
+  int24, int24be, int24le,
+  int32, int32be, int32le,
+  float, floatbe, floatle,
+  double, doublebe, doublele,
+  fixed16, fixed16be, fixed16le,
+  fixed32, fixed32be, fixed32le,
+  DecodeStream, EncodeStream
+} from 'restructure';
+import assert from 'assert';
+
+describe('Number', function() {
+  describe('uint8', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xab, 0xff]));
+      assert.equal(uint8.decode(stream), 0xab);
+      assert.equal(uint8.decode(stream), 0xff);
+    });
+
+    it('should have a size', () => assert.equal(uint8.size(), 1));
+
+    it('should encode', function() {
+      assert.deepEqual(uint8.toBuffer(0xab), new Uint8Array([0xab]));
+      assert.deepEqual(uint8.toBuffer(0xff), new Uint8Array([0xff]));
+    });
+  });
+
+  describe('uint16', () =>
+    it('is an alias for uint16be', () => assert.deepEqual(uint16, uint16be))
+  );
+
+  describe('uint16be', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xab, 0xff]));
+      assert.equal(uint16be.decode(stream), 0xabff);
+    });
+
+    it('should have a size', () => assert.equal(uint16be.size(), 2));
+
+    it('should encode', function() {
+      assert.deepEqual(uint16be.toBuffer(0xabff), new Uint8Array([0xab, 0xff]));
+    });
+  });
+
+  describe('uint16le', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xff, 0xab]));
+      assert.equal(uint16le.decode(stream), 0xabff);
+    });
+
+    it('should have a size', () => assert.equal(uint16le.size(), 2));
+
+    it('should encode', function() {
+      assert.deepEqual(uint16le.toBuffer(0xabff), new Uint8Array([0xff, 0xab]));
+    });
+  });
+
+  describe('uint24', () =>
+    it('is an alias for uint24be', () => assert.deepEqual(uint24, uint24be))
+  );
+
+  describe('uint24be', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24]));
+      assert.equal(uint24be.decode(stream), 0xffab24);
+    });
+
+    it('should have a size', () => assert.equal(uint24be.size(), 3));
+
+    it('should encode', function() {
+      assert.deepEqual(uint24be.toBuffer(0xffab24), new Uint8Array([0xff, 0xab, 0x24]));
+    });
+  });
+
+  describe('uint24le', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0x24, 0xab, 0xff]));
+      assert.equal(uint24le.decode(stream), 0xffab24);
+    });
+
+    it('should have a size', () => assert.equal(uint24le.size(), 3));
+
+    it('should encode', function() {
+      assert.deepEqual(uint24le.toBuffer(0xffab24), new Uint8Array([0x24, 0xab, 0xff]));
+    });
+  });
+
+  describe('uint32', () =>
+    it('is an alias for uint32be', () => assert.deepEqual(uint32, uint32be))
+  );
+
+  describe('uint32be', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
+      assert.equal(uint32be.decode(stream), 0xffab24bf);
+    });
+
+    it('should have a size', () => assert.equal(uint32be.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(uint32be.toBuffer(0xffab24bf), new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
+    });
+  });
+
+  describe('uint32le', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
+      assert.equal(uint32le.decode(stream), 0xffab24bf);
+    });
+
+    it('should have a size', () => assert.equal(uint32le.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(uint32le.toBuffer(0xffab24bf), new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
+    });
+  });
+
+  describe('int8', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0x7f, 0xff]));
+      assert.equal(int8.decode(stream), 127);
+      assert.equal(int8.decode(stream), -1);
+    });
+
+    it('should have a size', () => assert.equal(int8.size(), 1));
+
+    it('should encode', function() {
+      assert.deepEqual(uint8.toBuffer(127), new Uint8Array([0x7f]));
+      assert.deepEqual(uint8.toBuffer(-1), new Uint8Array([0xff]));
+    });
+  });
+
+  describe('int16', () =>
+    it('is an alias for int16be', () => assert.deepEqual(int16, int16be))
+  );
+
+  describe('int16be', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xff, 0xab]));
+      assert.equal(int16be.decode(stream), -85);
+    });
+
+    it('should have a size', () => assert.equal(int16be.size(), 2));
+
+    it('should encode', function() {
+      assert.deepEqual(int16be.toBuffer(-85), new Uint8Array([0xff, 0xab]));
+    });
+  });
+
+  describe('int16le', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xab, 0xff]));
+      assert.equal(int16le.decode(stream), -85);
+    });
+
+    it('should have a size', () => assert.equal(int16le.size(), 2));
+
+    it('should encode', function() {
+      assert.deepEqual(int16le.toBuffer(-85), new Uint8Array([0xab, 0xff]));
+    });
+  });
+
+  describe('int24', () =>
+    it('is an alias for int24be', () => assert.deepEqual(int24, int24be))
+  );
+
+  describe('int24be', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24]));
+      assert.equal(int24be.decode(stream), -21724);
+    });
+
+    it('should have a size', () => assert.equal(int24be.size(), 3));
+
+    it('should encode', function() {
+      assert.deepEqual(int24be.toBuffer(-21724), new Uint8Array([0xff, 0xab, 0x24]));
+    });
+  });
+
+  describe('int24le', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0x24, 0xab, 0xff]));
+      assert.equal(int24le.decode(stream), -21724);
+    });
+
+    it('should have a size', () => assert.equal(int24le.size(), 3));
+
+    it('should encode', function() {
+      assert.deepEqual(int24le.toBuffer(-21724), new Uint8Array([0x24, 0xab, 0xff]));
+    });
+  });
+
+  describe('int32', () =>
+    it('is an alias for int32be', () => assert.deepEqual(int32, int32be))
+  );
+
+  describe('int32be', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
+      assert.equal(int32be.decode(stream), -5561153);
+    });
+
+    it('should have a size', () => assert.equal(int32be.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(int32be.toBuffer(-5561153), new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
+    });
+  });
+
+  describe('int32le', function() {
+    it('should decode', function() {
+      const stream = new DecodeStream(new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
+      assert.equal(int32le.decode(stream), -5561153);
+    });
+
+    it('should have a size', () => assert.equal(int32le.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(int32le.toBuffer(-5561153), new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
+    });
+  });
+
+  describe('float', () =>
+    it('is an alias for floatbe', () => assert.deepEqual(float, floatbe))
+  );
+
+  describe('floatbe', function() {
+    it('should decode', function() {
+      const value = floatbe.fromBuffer(new Uint8Array([0x43, 0x7a, 0x8c, 0xcd]));
+      assert(value >= 250.55 - 0.005);
+      assert(value <= 250.55 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(floatbe.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(floatbe.toBuffer(250.55), new Uint8Array([0x43, 0x7a, 0x8c, 0xcd]));
+    });
+  });
+
+  describe('floatle', function() {
+    it('should decode', function() {
+      const value = floatle.fromBuffer(new Uint8Array([0xcd, 0x8c, 0x7a, 0x43]));
+      assert(value >= 250.55 - 0.005);
+      assert(value <= 250.55 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(floatle.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(floatle.toBuffer(250.55), new Uint8Array([0xcd, 0x8c, 0x7a, 0x43]));
+    });
+  });
+
+  describe('double', () =>
+    it('is an alias for doublebe', () => assert.deepEqual(double, doublebe))
+  );
+
+  describe('doublebe', function() {
+    it('should decode', function() {
+      const value = doublebe.fromBuffer(new Uint8Array([0x40, 0x93, 0x4a, 0x3d, 0x70, 0xa3, 0xd7, 0x0a]));
+      assert(value >= 1234.56 - 0.005);
+      assert(value <= 1234.56 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(doublebe.size(), 8));
+
+    it('should encode', function() {
+      assert.deepEqual(doublebe.toBuffer(1234.56), new Uint8Array([0x40, 0x93, 0x4a, 0x3d, 0x70, 0xa3, 0xd7, 0x0a]));
+    });
+  });
+
+  describe('doublele', function() {
+    it('should decode', function() {
+      const value = doublele.fromBuffer(new Uint8Array([0x0a, 0xd7, 0xa3, 0x70, 0x3d, 0x4a, 0x93, 0x40]));
+      assert(value >= 1234.56 - 0.005);
+      assert(value <= 1234.56 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(doublele.size(), 8));
+
+    it('should encode', function() {
+      assert.deepEqual(doublele.toBuffer(1234.56), new Uint8Array([0x0a, 0xd7, 0xa3, 0x70, 0x3d, 0x4a, 0x93, 0x40]));
+    });
+  });
+
+  describe('fixed16', () =>
+    it('is an alias for fixed16be', () => assert.deepEqual(fixed16, fixed16be))
+  );
+
+  describe('fixed16be', function() {
+    it('should decode', function() {
+      const value = fixed16be.fromBuffer(new Uint8Array([0x19, 0x57]));
+      assert(value >= 25.34 - 0.005);
+      assert(value <= 25.34 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(fixed16be.size(), 2));
+
+    it('should encode', function() {
+      assert.deepEqual(fixed16be.toBuffer(25.34), new Uint8Array([0x19, 0x57]));
+    });
+  });
+
+  describe('fixed16le', function() {
+    it('should decode', function() {
+      const value = fixed16le.fromBuffer(new Uint8Array([0x57, 0x19]));
+      assert(value >= 25.34 - 0.005);
+      assert(value <= 25.34 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(fixed16le.size(), 2));
+
+    it('should encode', function() {
+      assert.deepEqual(fixed16le.toBuffer(25.34), new Uint8Array([0x57, 0x19]));
+    });
+  });
+
+  describe('fixed32', () =>
+    it('is an alias for fixed32be', () => assert.deepEqual(fixed32, fixed32be))
+  );
+
+  describe('fixed32be', function() {
+    it('should decode', function() {
+      const value = fixed32be.fromBuffer(new Uint8Array([0x00, 0xfa, 0x8c, 0xcc]));
+      assert(value >= 250.55 - 0.005);
+      assert(value <= 250.55 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(fixed32be.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(fixed32be.toBuffer(250.55), new Uint8Array([0x00, 0xfa, 0x8c, 0xcc]));
+    });
+  });
+
+  describe('fixed32le', function() {
+    it('should decode', function() {
+      const value = fixed32le.fromBuffer(new Uint8Array([0xcc, 0x8c, 0xfa, 0x00]));
+      assert(value >= 250.55 - 0.005);
+      assert(value <= 250.55 + 0.005);
+    });
+
+    it('should have a size', () => assert.equal(fixed32le.size(), 4));
+
+    it('should encode', function() {
+      assert.deepEqual(fixed32le.toBuffer(250.55), new Uint8Array([0xcc, 0x8c, 0xfa, 0x00]));
+    });
+  });
+});

package/node_modules/restructure/test/Optional.js

@@ -0,0 +1,100 @@
+import assert from 'assert';
+import {Optional, uint8, DecodeStream, EncodeStream} from 'restructure';
+
+describe('Optional', function() {
+  describe('decode', function() {
+    it('should not decode when condition is falsy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, false);
+      assert.equal(optional.decode(stream), null);
+      assert.equal(stream.pos, 0);
+    });
+
+    it('should not decode when condition is a function and falsy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, function() { return false; });
+      assert.equal(optional.decode(stream), null);
+      assert.equal(stream.pos, 0);
+    });
+
+    it('should decode when condition is omitted', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8);
+      assert(optional.decode(stream) != null);
+      assert.equal(stream.pos, 1);
+    });
+
+    it('should decode when condition is truthy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, true);
+      assert(optional.decode(stream) != null);
+      assert.equal(stream.pos, 1);
+    });
+
+    it('should decode when condition is a function and truthy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, function() { return true; });
+      assert(optional.decode(stream) != null);
+      assert.equal(stream.pos, 1);
+    });
+  });
+
+  describe('size', function() {
+    it('should return 0 when condition is falsy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, false);
+      assert.equal(optional.size(), 0);
+    });
+
+    it('should return 0 when condition is a function and falsy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, function() { return false; });
+      assert.equal(optional.size(), 0);
+    });
+
+    it('should return given type size when condition is omitted', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8);
+      assert.equal(optional.size(), 1);
+    });
+
+    it('should return given type size when condition is truthy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, true);
+      assert.equal(optional.size(), 1);
+    });
+
+    it('should return given type size when condition is a function and truthy', function() {
+      const stream = new DecodeStream(new Uint8Array([0]));
+      const optional = new Optional(uint8, function() { return true; });
+      assert.equal(optional.size(), 1);
+    });
+  });
+
+  describe('encode', function() {
+    it('should not encode when condition is falsy', function() {
+      const optional = new Optional(uint8, false);
+      assert.deepEqual(optional.toBuffer(128), new Uint8Array(0));
+    });
+
+    it('should not encode when condition is a function and falsy', function() {
+      const optional = new Optional(uint8, function() { return false; });
+      assert.deepEqual(optional.toBuffer(128), new Uint8Array(0));
+    });
+
+    it('should encode when condition is omitted', function() {
+      const optional = new Optional(uint8);
+      assert.deepEqual(optional.toBuffer(128), new Uint8Array([128]));
+    });
+
+    it('should encode when condition is truthy', function() {
+      const optional = new Optional(uint8, true);
+      assert.deepEqual(optional.toBuffer(128), new Uint8Array([128]));
+    });
+
+    it('should encode when condition is a function and truthy', function() {
+      const optional = new Optional(uint8, function() { return true; });
+      assert.deepEqual(optional.toBuffer(128), new Uint8Array([128]));
+    });
+  });
+});