ripple-binary-codec 0.3.0-rc1 → 1.0.0-mpt-beta

package/test/binary-serializer-test.js

@@ -1,194 +0,0 @@
-/* eslint-disable func-style */
-
-const BN = require('bn.js');
-const assert = require('assert');
-const lib = require('../src/coretypes');
-const encode = require('../src').encode;
-const {binary: {makeParser, BytesList, BinarySerializer}} = lib;
-const {UInt8, UInt16, UInt32, UInt64, STObject} = lib;
-const {loadFixture} = require('./utils');
-const fixtures = loadFixture('data-driven-tests.json');
-const deliverMinTx = require('./fixtures/delivermin-tx.json');
-const deliverMinTxBinary = require('./fixtures/delivermin-tx-binary.json');
-const SignerListSet = {
-  tx: require('./fixtures/signerlistset-tx.json'),
-  binary: require('./fixtures/signerlistset-tx-binary.json'),
-  meta: require('./fixtures/signerlistset-tx-meta-binary.json')
-};
-const DepositPreauth = {
-  tx: require('./fixtures/deposit-preauth-tx.json'),
-  binary: require('./fixtures/deposit-preauth-tx-binary.json'),
-  meta: require('./fixtures/deposit-preauth-tx-meta-binary.json')
-};
-const Escrow = {
-  create: {
-    tx: require('./fixtures/escrow-create-tx.json'),
-    binary: require('./fixtures/escrow-create-binary.json')
-  },
-  finish: {
-    tx: require('./fixtures/escrow-finish-tx.json'),
-    binary: require('./fixtures/escrow-finish-binary.json'),
-    meta: require('./fixtures/escrow-finish-meta-binary.json')
-  },
-  cancel: {
-    tx: require('./fixtures/escrow-cancel-tx.json'),
-    binary: require('./fixtures/escrow-cancel-binary.json')
-  }
-}
-const PaymentChannel = {
-  create: {
-    tx: require('./fixtures/payment-channel-create-tx.json'),
-    binary: require('./fixtures/payment-channel-create-binary.json')
-  },
-  fund: {
-    tx: require('./fixtures/payment-channel-fund-tx.json'),
-    binary: require('./fixtures/payment-channel-fund-binary.json')
-  },
-  claim: {
-    tx: require('./fixtures/payment-channel-claim-tx.json'),
-    binary: require('./fixtures/payment-channel-claim-binary.json')
-  }
-}
-
-function bytesListTest() {
-  const list = new BytesList().put([0]).put([2, 3]).put([4, 5]);
-  it('is an Array<Uint8Array>', function() {
-    assert(Array.isArray(list.arrays));
-    assert(list.arrays[0] instanceof Uint8Array);
-  });
-  it('keeps track of the length itself', function() {
-    assert.equal(list.length, 5);
-  });
-  it('can join all arrays into one via toBytes', function() {
-    const joined = list.toBytes();
-    assert(joined.length, 5);
-    assert.deepEqual(joined, Uint8Array.from([0, 2, 3, 4, 5]));
-  });
-}
-
-function assertRecycles(blob) {
-  const parser = makeParser(blob);
-  const so = parser.readType(STObject);
-  const out = new BytesList();
-  so.toBytesSink(out);
-  const hex = out.toHex();
-  assert.equal(hex, blob);
-  assert.notEqual(hex + ':', blob);
-}
-
-function nestedObjectTests() {
-  fixtures.whole_objects.forEach((f, i) => {
-    it(`whole_objects[${i}]: can parse blob and dump out same blob`,
-    /*                                              */ () => {
-        assertRecycles(f.blob_with_no_signing);
-      });
-  });
-}
-
-function UIntTest() {
-  function check(type, n, expected) {
-    it(`Uint${type.width * 8} serializes ${n} as ${expected}`, function() {
-      const bl = new BytesList();
-      const serializer = new BinarySerializer(bl);
-      if (expected === 'throws') {
-        assert.throws(() => serializer.writeType(type, n));
-        return;
-      }
-      serializer.writeType(type, n);
-      assert.deepEqual(bl.toBytes(), Uint8Array.from(expected));
-    });
-  }
-
-  check(UInt8, 5, [5]);
-  check(UInt16, 5, [0, 5]);
-  check(UInt32, 5, [0, 0, 0, 5]);
-  check(UInt32, 0xFFFFFFFF, [255, 255, 255, 255]);
-  check(UInt8, 0xFEFFFFFF, 'throws');
-  check(UInt16, 0xFEFFFFFF, 'throws');
-  check(UInt16, 0xFEFFFFFF, 'throws');
-  check(UInt64, 0xFEFFFFFF, [0, 0, 0, 0, 254, 255, 255, 255]);
-  check(UInt64, -1, 'throws');
-  check(UInt64, 0, [0, 0, 0, 0, 0, 0, 0, 0]);
-  check(UInt64, 1, [0, 0, 0, 0, 0, 0, 0, 1]);
-  check(UInt64, new BN(1), [0, 0, 0, 0, 0, 0, 0, 1]);
-}
-
-
-function parseLedger4320278() {
-  it('can parse object', done => {
-    this.timeout(30e3);
-    const json = loadFixture('as-ledger-4320278.json');
-    json.forEach(e => {
-      assertRecycles(e.binary);
-    });
-    done();
-  });
-}
-
-function deliverMinTest() {
-  it('can serialize DeliverMin', () => {
-    assert.strictEqual(encode(deliverMinTx), deliverMinTxBinary);
-  });
-}
-
-function SignerListSetTest() {
-  it('can serialize SignerListSet', () => {
-    assert.strictEqual(encode(SignerListSet.tx), SignerListSet.binary);
-  });
-  it('can serialize SignerListSet metadata', () => {
-    assert.strictEqual(encode(SignerListSet.tx.meta), SignerListSet.meta);
-  });
-}
-
-function DepositPreauthTest() {
-  it('can serialize DepositPreauth', () => {
-    assert.strictEqual(encode(DepositPreauth.tx), DepositPreauth.binary);
-  });
-  it('can serialize DepositPreauth metadata', () => {
-    assert.strictEqual(encode(DepositPreauth.tx.meta), DepositPreauth.meta);
-  });
-}
-
-function EscrowTest() {
-  it('can serialize EscrowCreate', () => {
-    assert.strictEqual(encode(Escrow.create.tx),
-      Escrow.create.binary);
-  });
-  it('can serialize EscrowFinish', () => {
-    assert.strictEqual(encode(Escrow.finish.tx),
-      Escrow.finish.binary);
-    assert.strictEqual(encode(Escrow.finish.tx.meta),
-      Escrow.finish.meta);
-  });
-  it('can serialize EscrowCancel', () => {
-    assert.strictEqual(encode(Escrow.cancel.tx),
-      Escrow.cancel.binary);
-  });
-}
-
-function PaymentChannelTest() {
-  it('can serialize PaymentChannelCreate', () => {
-    assert.strictEqual(encode(PaymentChannel.create.tx),
-      PaymentChannel.create.binary);
-  });
-  it('can serialize PaymentChannelFund', () => {
-    assert.strictEqual(encode(PaymentChannel.fund.tx),
-      PaymentChannel.fund.binary);
-  });
-  it('can serialize PaymentChannelClaim', () => {
-    assert.strictEqual(encode(PaymentChannel.claim.tx),
-      PaymentChannel.claim.binary);
-  });
-}
-
-describe('Binary Serialization', function() {
-  describe.skip('parseLedger4320278', parseLedger4320278);
-  describe('nestedObjectTests', nestedObjectTests);
-  describe('UIntTest', UIntTest);
-  describe('BytesList', bytesListTest);
-  describe('DeliverMin', deliverMinTest);
-  describe('DepositPreauth', DepositPreauthTest);
-  describe('SignerListSet', SignerListSetTest);
-  describe('Escrow', EscrowTest);
-  describe('PaymentChannel', PaymentChannelTest);
-});

package/test/bytes-utils-test.js

@@ -1,72 +0,0 @@
-const assert = require('assert');
-const bytesUtils = require('../src/utils/bytes-utils');
-const {slice, compareBytes, parseBytes, bytesToHex} = bytesUtils;
-
-describe('bytes-utils', function() {
-  describe('parseBytes', function() {
-    it('can decode hex', function() {
-      assert.deepEqual(parseBytes('0012'), [0x00, 0x12]);
-      assert.deepEqual(parseBytes('0012'), [0x00, 0x12]);
-      assert.deepEqual(parseBytes('00AA'), [0x00, 0xaa]);
-    });
-    it('can decode hex to a Uint8Array', function() {
-      const result = parseBytes('0012', Uint8Array);
-      assert(result instanceof Uint8Array);
-      assert.deepEqual(result, Uint8Array.from([0x00, 0x12]));
-    });
-    it('can convert a list to a Uint8Array', function() {
-      const result = parseBytes([0x00, 0x12], Uint8Array);
-      assert(result instanceof Uint8Array);
-      assert.deepEqual(result, Uint8Array.from([0x00, 0x12]));
-    });
-    it('can decode hex to a Buffer', function() {
-      const result = parseBytes('0012', Buffer);
-      assert(result instanceof Buffer);
-      assert.deepEqual(result.toJSON().data, [0x00, 0x12]);
-    });
-  });
-
-  describe('bytesToHex', function() {
-    it('can encode an array as hex', function() {
-      assert.deepEqual(bytesToHex([0x00, 0xaa]), '00AA');
-      assert.deepEqual(bytesToHex([0xaa]), 'AA');
-    });
-    it('can encode Uint8Array as hex', function() {
-      assert.deepEqual(bytesToHex(new Uint8Array([0x00, 0xaa])), '00AA');
-      assert.deepEqual(bytesToHex(new Uint8Array([0xaa])), 'AA');
-    });
-  });
-
-  describe('compareBytes', function() {
-    it('compares the bytes sequence as big endian number', function() {
-      assert.equal(compareBytes([0, 1, 2], [1, 2, 3]), -1);
-    });
-    it('throws when the bytes sequences are of unlike length', function() {
-      assert.throws(() => compareBytes([0, 1], [1]));
-    });
-  });
-
-  describe('slice', function() {
-    const val = [1, 2, 3, 4, 5];
-    it('creates a slice of the same type as first arg', function() {
-      assert(Array.isArray(slice(val)));
-    });
-    it('the 2nd arg is the start position [2:]', function() {
-      assert.deepEqual(val.slice(2), [3, 4, 5]);
-      assert.deepEqual(slice(val, 2), [3, 4, 5]);
-    });
-    it('the 3rd arg is the end position [2:4]', function() {
-      assert.deepEqual(slice(val, 2, 4), [3, 4]);
-    });
-    it('can slice using negative numbers [-3:]', function() {
-      assert.deepEqual(slice(val, -3), [3, 4, 5]);
-    });
-    it('can slice using negative numbers [-3:-1]', function() {
-      assert.deepEqual(slice(val, -3, -1), [3, 4]);
-    });
-    it('the 4th arg is the output class type', function() {
-      assert.deepEqual(slice(val, 2, 4, Buffer).toJSON().data, [3, 4]);
-      assert.deepEqual(slice(val, 2, 4, Uint8Array), Uint8Array.from([3, 4]));
-    });
-  });
-});