diff --git a/test/amount-test.js b/test/amount-test.js index fcc72b73..f133ca64 100644 --- a/test/amount-test.js +++ b/test/amount-test.js @@ -2,7 +2,6 @@ var assert = require('assert'); var jsbn = require('../src/js/ripple/jsbn'); var BigInteger = jsbn.BigInteger; -var _ = require('underscore'); var Amount = require('../src/js/ripple/amount').Amount; var UInt160 = require('../src/js/ripple/uint160').UInt160; @@ -22,13 +21,13 @@ describe('Amount', function() { }); describe('UInt160', function() { it('Parse 0', function () { - assert(_.isEqual(jsbn.nbi(), UInt160.from_generic('0')._value)); + assert.deepEqual(jsbn.nbi(), UInt160.from_generic('0')._value); }); it('Parse 0 export', function () { assert.strictEqual(UInt160.ACCOUNT_ZERO, UInt160.from_generic('0').to_json()); }); it('Parse 1', function () { - assert(_.isEqual(new BigInteger([1]), UInt160.from_generic('1')._value)); + assert.deepEqual(new BigInteger([1]), UInt160.from_generic('1')._value); }); it('Parse rrrrrrrrrrrrrrrrrrrrrhoLvTp export', function () { assert.strictEqual(UInt160.ACCOUNT_ZERO, UInt160.from_json('rrrrrrrrrrrrrrrrrrrrrhoLvTp').to_json()); diff --git a/test/serializedobject-test.js b/test/serializedobject-test.js index 549d9bb3..ac7e9a20 100644 --- a/test/serializedobject-test.js +++ b/test/serializedobject-test.js @@ -1,5 +1,4 @@ var assert = require('assert'); -var _ = require('underscore'); var SerializedObject = require('../src/js/ripple/serializedobject').SerializedObject; describe('Serialied object', function() { @@ -32,7 +31,7 @@ describe('Serialied object', function() { TxnSignature: '30450221009DA3A42DD25E3B22EC45AD8BA8FC7A954264264A816D300B2DF69F814D7D4DD2022072C9627F97EEC6DA13DE841E06E2CD985EF06A0FBB15DDBF0800D0730C8986BF' }; var output_json = SerializedObject.from_json(input_json).to_json(); - assert(_.isEqual(input_json, output_json)); + assert.deepEqual(input_json, output_json); }); }); }); diff --git a/test/serializedtypes-test.js b/test/serializedtypes-test.js index 366d3c05..5b065572 100644 --- a/test/serializedtypes-test.js +++ b/test/serializedtypes-test.js @@ -1,5 +1,4 @@ -var buster = require('buster'); - +var assert = require('assert'); var SerializedObject = require('../src/js/ripple/serializedobject').SerializedObject; var types = require('../src/js/ripple/serializedtypes'); @@ -13,55 +12,55 @@ describe('Serialized types', function() { it('Serialize 0', function () { var so = new SerializedObject(); types.Int8.serialize(so, 0); - assert.equals(so.to_hex(), '00'); + assert.strictEqual(so.to_hex(), '00'); }); it('Serialize 123', function () { var so = new SerializedObject(); types.Int8.serialize(so, 123); - assert.equals(so.to_hex(), '7B'); + assert.strictEqual(so.to_hex(), '7B'); }); it('Serialize 255', function () { var so = new SerializedObject(); types.Int8.serialize(so, 255); - assert.equals(so.to_hex(), 'FF'); + assert.strictEqual(so.to_hex(), 'FF'); }); it('Fail to serialize 256', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, 256); }); }); it('Fail to serialize -1', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, -1); }); }); it('Serialize 5.5 (should floor)', function () { var so = new SerializedObject(); types.Int8.serialize(so, 5.5); - assert.equals(so.to_hex(), '05'); + assert.strictEqual(so.to_hex(), '05'); }); it('Serialize 255.9 (should floor)', function () { var so = new SerializedObject(); types.Int8.serialize(so, 255.9); - assert.equals(so.to_hex(), 'FF'); + assert.strictEqual(so.to_hex(), 'FF'); }); it('Fail to serialize null', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, null); }); }); it('Fail to serialize "bla"', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, 'bla'); }); }); it('Fail to serialize {}', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, {}); }); }); @@ -71,65 +70,65 @@ describe('Serialized types', function() { it('Serialize 0', function () { var so = new SerializedObject(); types.Int16.serialize(so, 0); - assert.equals(so.to_hex(), '0000'); + assert.strictEqual(so.to_hex(), '0000'); }); it('Serialize 123', function () { var so = new SerializedObject(); types.Int16.serialize(so, 123); - assert.equals(so.to_hex(), '007B'); + assert.strictEqual(so.to_hex(), '007B'); }); it('Serialize 255', function () { var so = new SerializedObject(); types.Int16.serialize(so, 255); - assert.equals(so.to_hex(), '00FF'); + assert.strictEqual(so.to_hex(), '00FF'); }); it('Serialize 256', function () { var so = new SerializedObject(); types.Int16.serialize(so, 256); - assert.equals(so.to_hex(), '0100'); + assert.strictEqual(so.to_hex(), '0100'); }); it('Serialize 65535', function () { var so = new SerializedObject(); types.Int16.serialize(so, 65535); - assert.equals(so.to_hex(), 'FFFF'); + assert.strictEqual(so.to_hex(), 'FFFF'); }); it('Fail to serialize 65536', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, 65536); }); }); it('Fail to serialize -1', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int16.serialize(so, -1); }); }); it('Serialize 123.5 (should floor)', function () { var so = new SerializedObject(); types.Int16.serialize(so, 123.5); - assert.equals(so.to_hex(), '007B'); + assert.strictEqual(so.to_hex(), '007B'); }); it('Serialize 65535.5 (should floor)', function () { var so = new SerializedObject(); types.Int16.serialize(so, 65535.5); - assert.equals(so.to_hex(), 'FFFF'); + assert.strictEqual(so.to_hex(), 'FFFF'); }); it('Fail to serialize null', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int16.serialize(so, null); }); }); it('Fail to serialize "bla"', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int16.serialize(so, 'bla'); }); }); it('Fail to serialize {}', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int16.serialize(so, {}); }); }); @@ -139,70 +138,70 @@ describe('Serialized types', function() { it('Serialize 0', function () { var so = new SerializedObject(); types.Int32.serialize(so, 0); - assert.equals(so.to_hex(), '00000000'); + assert.strictEqual(so.to_hex(), '00000000'); }); it('Serialize 123', function () { var so = new SerializedObject(); types.Int32.serialize(so, 123); - assert.equals(so.to_hex(), '0000007B'); + assert.strictEqual(so.to_hex(), '0000007B'); }); it('Serialize 255', function () { var so = new SerializedObject(); types.Int32.serialize(so, 255); - assert.equals(so.to_hex(), '000000FF'); + assert.strictEqual(so.to_hex(), '000000FF'); }); it('Serialize 256', function () { var so = new SerializedObject(); types.Int32.serialize(so, 256); - assert.equals(so.to_hex(), '00000100'); + assert.strictEqual(so.to_hex(), '00000100'); }); it('Serialize 0xF0F0F0F0', function () { var so = new SerializedObject(); types.Int32.serialize(so, 0xF0F0F0F0); - assert.equals(so.to_hex(), 'F0F0F0F0'); + assert.strictEqual(so.to_hex(), 'F0F0F0F0'); }); it('Serialize 0xFFFFFFFF', function () { var so = new SerializedObject(); types.Int32.serialize(so, 0xFFFFFFFF); - assert.equals(so.to_hex(), 'FFFFFFFF'); + assert.strictEqual(so.to_hex(), 'FFFFFFFF'); }); it('Fail to serialize 0x100000000', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, 0x100000000); }); }); it('Fail to serialize -1', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int32.serialize(so, -1); }); }); it('Serialize 123.5 (should floor)', function () { var so = new SerializedObject(); types.Int32.serialize(so, 123.5); - assert.equals(so.to_hex(), '0000007B'); + assert.strictEqual(so.to_hex(), '0000007B'); }); it('Serialize 4294967295.5 (should floor)', function () { var so = new SerializedObject(); types.Int32.serialize(so, 4294967295.5); - assert.equals(so.to_hex(), 'FFFFFFFF'); + assert.strictEqual(so.to_hex(), 'FFFFFFFF'); }); it('Fail to serialize null', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int32.serialize(so, null); }); }); it('Fail to serialize "bla"', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int32.serialize(so, 'bla'); }); }); it('Fail to serialize {}', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int32.serialize(so, {}); }); }); @@ -212,108 +211,108 @@ describe('Serialized types', function() { it('Serialize 0', function () { var so = new SerializedObject(); types.Int64.serialize(so, 0); - assert.equals(so.to_hex(), '0000000000000000'); + assert.strictEqual(so.to_hex(), '0000000000000000'); }); it('Serialize 123', function () { var so = new SerializedObject(); types.Int64.serialize(so, 123); - assert.equals(so.to_hex(), '000000000000007B'); + assert.strictEqual(so.to_hex(), '000000000000007B'); }); it('Serialize 255', function () { var so = new SerializedObject(); types.Int64.serialize(so, 255); - assert.equals(so.to_hex(), '00000000000000FF'); + assert.strictEqual(so.to_hex(), '00000000000000FF'); }); it('Serialize 256', function () { var so = new SerializedObject(); types.Int64.serialize(so, 256); - assert.equals(so.to_hex(), '0000000000000100'); + assert.strictEqual(so.to_hex(), '0000000000000100'); }); it('Serialize 0xF0F0F0F0', function () { var so = new SerializedObject(); types.Int64.serialize(so, 0xF0F0F0F0); - assert.equals(so.to_hex(), '00000000F0F0F0F0'); + assert.strictEqual(so.to_hex(), '00000000F0F0F0F0'); }); it('Serialize 0xFFFFFFFF', function () { var so = new SerializedObject(); types.Int64.serialize(so, 0xFFFFFFFF); - assert.equals(so.to_hex(), '00000000FFFFFFFF'); + assert.strictEqual(so.to_hex(), '00000000FFFFFFFF'); }); it('Serialize 0x100000000', function () { var so = new SerializedObject(); types.Int64.serialize(so, 0x100000000); - assert.equals(so.to_hex(), '0000000100000000'); + assert.strictEqual(so.to_hex(), '0000000100000000'); }); it('Fail to serialize 0x100000000', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int8.serialize(so, 0x100000000); }); }); it('Fail to serialize -1', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, -1); }); }); it('Serialize 123.5 (should floor)', function () { var so = new SerializedObject(); types.Int64.serialize(so, 123.5); - assert.equals(so.to_hex(), '000000000000007B'); + assert.strictEqual(so.to_hex(), '000000000000007B'); }); it('Serialize 4294967295.5 (should floor)', function () { var so = new SerializedObject(); types.Int64.serialize(so, 4294967295.5); - assert.equals(so.to_hex(), '00000000FFFFFFFF'); + assert.strictEqual(so.to_hex(), '00000000FFFFFFFF'); }); it('Serialize "0123456789ABCDEF"', function () { var so = new SerializedObject(); types.Int64.serialize(so, '0123456789ABCDEF'); - assert.equals(so.to_hex(), '0123456789ABCDEF'); + assert.strictEqual(so.to_hex(), '0123456789ABCDEF'); }); it('Serialize "F0E1D2C3B4A59687"', function () { var so = new SerializedObject(); types.Int64.serialize(so, 'F0E1D2C3B4A59687'); - assert.equals(so.to_hex(), 'F0E1D2C3B4A59687'); + assert.strictEqual(so.to_hex(), 'F0E1D2C3B4A59687'); }); it('Serialize BigInteger("FFEEDDCCBBAA9988")', function () { var so = new SerializedObject(); types.Int64.serialize(so, new BigInteger('FFEEDDCCBBAA9988', 16)); - assert.equals(so.to_hex(), 'FFEEDDCCBBAA9988'); + assert.strictEqual(so.to_hex(), 'FFEEDDCCBBAA9988'); }); it('Fail to serialize BigInteger("-1")', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, new BigInteger('-1', 10)); }); }); it('Fail to serialize "10000000000000000"', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, '10000000000000000'); }); }); it('Fail to serialize "110000000000000000"', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, '110000000000000000'); }); }); it('Fail to serialize null', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, null); }); }); it('Fail to serialize "bla"', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, 'bla'); }); }); it('Fail to serialize {}', function () { var so = new SerializedObject(); - assert.exception(function () { + assert.throws(function () { types.Int64.serialize(so, {}); }); }); @@ -323,17 +322,17 @@ describe('Serialized types', function() { it('Serialize 0', function () { var so = new SerializedObject(); types.Hash128.serialize(so, '00000000000000000000000000000000'); - assert.equals(so.to_hex(), '00000000000000000000000000000000'); + assert.strictEqual(so.to_hex(), '00000000000000000000000000000000'); }); it('Serialize 102030405060708090A0B0C0D0E0F000', function () { var so = new SerializedObject(); types.Hash128.serialize(so, '102030405060708090A0B0C0D0E0F000'); - assert.equals(so.to_hex(), '102030405060708090A0B0C0D0E0F000'); + assert.strictEqual(so.to_hex(), '102030405060708090A0B0C0D0E0F000'); }); it('Serialize FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', function () { var so = new SerializedObject(); types.Hash128.serialize(so, 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'); - assert.equals(so.to_hex(), 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'); + assert.strictEqual(so.to_hex(), 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'); }); }); @@ -341,17 +340,17 @@ describe('Serialized types', function() { it('Serialize 0', function () { var so = new SerializedObject(); types.Hash160.serialize(so, 'rrrrrrrrrrrrrrrrrrrrrhoLvTp'); - assert.equals(so.to_hex(), '0000000000000000000000000000000000000000'); + assert.strictEqual(so.to_hex(), '0000000000000000000000000000000000000000'); }); it('Serialize 1', function () { var so = new SerializedObject(); types.Hash160.serialize(so, 'rrrrrrrrrrrrrrrrrrrrBZbvji'); - assert.equals(so.to_hex(), '0000000000000000000000000000000000000001'); + assert.strictEqual(so.to_hex(), '0000000000000000000000000000000000000001'); }); it('Serialize FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', function () { var so = new SerializedObject(); types.Hash160.serialize(so, 'rQLbzfJH5BT1FS9apRLKV3G8dWEA5njaQi'); - assert.equals(so.to_hex(), 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'); + assert.strictEqual(so.to_hex(), 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'); }); }); @@ -359,79 +358,79 @@ describe('Serialized types', function() { it('Serialize 0 XRP', function () { var so = new SerializedObject(); types.Amount.serialize(so, '0'); - assert.equals(so.to_hex(), '4000000000000000'); + assert.strictEqual(so.to_hex(), '4000000000000000'); }); it('Serialize 1 XRP', function () { var so = new SerializedObject(); types.Amount.serialize(so, '1'); - assert.equals(so.to_hex(), '4000000000000001'); + assert.strictEqual(so.to_hex(), '4000000000000001'); }); it('Serialize -1 XRP', function () { var so = new SerializedObject(); types.Amount.serialize(so, '-1'); - assert.equals(so.to_hex(), '0000000000000001'); + assert.strictEqual(so.to_hex(), '0000000000000001'); }); it('Serialize 213 XRP', function () { var so = new SerializedObject(); types.Amount.serialize(so, '213'); - assert.equals(so.to_hex(), '40000000000000D5'); + assert.strictEqual(so.to_hex(), '40000000000000D5'); }); it('Serialize 270544960 XRP', function () { var so = new SerializedObject(); types.Amount.serialize(so, '270544960'); - assert.equals(so.to_hex(), '4000000010203040'); + assert.strictEqual(so.to_hex(), '4000000010203040'); }); it('Serialize 1161981756646125568 XRP', function () { var so = new SerializedObject(); types.Amount.serialize(so, '1161981756646125696'); - assert.equals(so.to_hex(), '5020304050607080'); + assert.strictEqual(so.to_hex(), '5020304050607080'); }); it('Serialize 1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function () { var so = new SerializedObject(); types.Amount.serialize(so, '1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); - assert.equals(so.to_hex(), 'D4838D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); + assert.strictEqual(so.to_hex(), 'D4838D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); }); it('Serialize 87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function () { var so = new SerializedObject(); types.Amount.serialize(so, '87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); - assert.equals(so.to_hex(), 'D65F241D335BF24E0000000000000000000000004555520000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); + assert.strictEqual(so.to_hex(), 'D65F241D335BF24E0000000000000000000000004555520000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); }); it('Serialize -1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function () { var so = new SerializedObject(); types.Amount.serialize(so, '-1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); - assert.equals(so.to_hex(), '94838D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); + assert.strictEqual(so.to_hex(), '94838D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); }); it('Parse 1 XRP', function () { var so = new SerializedObject('4000000000000001'); - assert.equals(types.Amount.parse(so).to_json(), '1'); + assert.strictEqual(types.Amount.parse(so).to_json(), '1'); }); it('Parse -1 XRP', function () { var so = new SerializedObject('0000000000000001'); - assert.equals(types.Amount.parse(so).to_json(), '-1'); + assert.strictEqual(types.Amount.parse(so).to_json(), '-1'); }); it('Parse 213 XRP', function () { var so = new SerializedObject('40000000000000D5'); - assert.equals(types.Amount.parse(so).to_json(), '213'); + assert.strictEqual(types.Amount.parse(so).to_json(), '213'); }); it('Parse 270544960 XRP', function () { var so = new SerializedObject('4000000010203040'); - assert.equals(types.Amount.parse(so).to_json(), '270544960'); + assert.strictEqual(types.Amount.parse(so).to_json(), '270544960'); }); it('Parse 1161981756646125568 XRP', function () { var so = new SerializedObject('5020304050607080'); - assert.equals(types.Amount.parse(so).to_json(), '1161981756646125696'); + assert.strictEqual(types.Amount.parse(so).to_json(), '1161981756646125696'); }); it('Parse 1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function () { var so = new SerializedObject('D4838D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); - assert.equals(types.Amount.parse(so).to_text_full(), '1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); + assert.strictEqual(types.Amount.parse(so).to_text_full(), '1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); }); it('Parse 87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function () { var so = new SerializedObject('D65F241D335BF24E0000000000000000000000004555520000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); - assert.equals(types.Amount.parse(so).to_text_full(), '87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); + assert.strictEqual(types.Amount.parse(so).to_text_full(), '87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); }); it('Parse -1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function () { var so = new SerializedObject('94838D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E8'); - assert.equals(types.Amount.parse(so).to_text_full(), '-1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); + assert.strictEqual(types.Amount.parse(so).to_text_full(), '-1/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'); }); }); @@ -439,22 +438,49 @@ describe('Serialized types', function() { it('Serialize single empty path [[]]', function () { var so = new SerializedObject(); types.PathSet.serialize(so, [[]]); - assert.equals(so.to_hex(), '00'); + assert.strictEqual(so.to_hex(), '00'); }); it('Serialize [[e],[e,e]]', function () { var so = new SerializedObject(); - types.PathSet.serialize(so, [[{account:123, currency:'USD', issuer:789}],[{account:123, currency:'BTC', issuer:789}, {account:987, currency:'EUR', issuer:321}]]); - assert.equals(so.to_hex(), '31000000000000000000000000000000000000007B00000000000000000000000055534400000000000000000000000000000000000000000000000315FF31000000000000000000000000000000000000007B000000000000000000000000425443000000000000000000000000000000000000000000000003153100000000000000000000000000000000000003DB0000000000000000000000004555520000000000000000000000000000000000000000000000014100'); //TODO: Check this independently + types.PathSet.serialize(so, [[ { + account: 123, + currency: 'USD', + issuer: 789 + }], + [{ + account: 123, + currency: 'BTC', + issuer: 789 + }, + { + account: 987, + currency: 'EUR', + issuer: 321 + }]]); + assert.strictEqual(so.to_hex(), '31000000000000000000000000000000000000007B00000000000000000000000055534400000000000000000000000000000000000000000000000315FF31000000000000000000000000000000000000007B000000000000000000000000425443000000000000000000000000000000000000000000000003153100000000000000000000000000000000000003DB0000000000000000000000004555520000000000000000000000000000000000000000000000014100'); //TODO: Check this independently }); it('Parse single empty path [[]]', function () { var so = new SerializedObject('00'); - var parsed_path=types.PathSet.parse(so) - assert.equals(parsed_path,[[]]); + var parsed_path = types.PathSet.parse(so) + assert.deepEqual(parsed_path, [[]]); }); it('Parse [[e],[e,e]]', function () { var so = new SerializedObject('31000000000000000000000000000000000000007B00000000000000000000000055534400000000000000000000000000000000000000000000000315FF31000000000000000000000000000000000000007B000000000000000000000000425443000000000000000000000000000000000000000000000003153100000000000000000000000000000000000003DB0000000000000000000000004555520000000000000000000000000000000000000000000000014100'); - parsed_path=types.PathSet.parse(so); - assert.equals(parsed_path,[[{account:{_value:123}, currency:{_value:'USD'}, issuer:{_value:789}}],[{account:{_value:123}, currency:{_value:'BTC'}, issuer:{_value:789}},{account:{_value:987}, currency:{_value:'EUR'}, issuer:{_value:321}}]]); + parsed_path = types.PathSet.parse(so); + assert.deepEqual(parsed_path, [[{ + account : { _value: 123 }, + currency: {_value: 'USD'}, + issuer: {_value: 789}}], + [{ + account : {_value: 123}, + currency: {_value: 'BTC'}, + issuer: {_value: 789} + }, + { + account : {_value: 987}, + currency: {_value: 'EUR'}, + issuer: {_value: 321} + }]]); }); }); @@ -462,59 +488,65 @@ describe('Serialized types', function() { it('Serialize empty object {}', function () { var so = new SerializedObject(); types.Object.serialize(so, {}); - assert.equals(so.to_hex(), 'E1'); + assert.strictEqual(so.to_hex(), 'E1'); }); it('Parse empty object {}', function () { var so = new SerializedObject('E1'); - var parsed_object=types.Object.parse(so) - assert.equals(parsed_object,{}); + var parsed_object = types.Object.parse(so) + assert.deepEqual(parsed_object, { }); }); it('Serialize simple object {TakerPays:"87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", TakerGets:213, Fee:"789"}', function () { var so = new SerializedObject(); - types.Object.serialize(so, {'TakerPays':'87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', 'TakerGets':'213', 'Fee':789}); - assert.equals(so.to_hex(), '64D65F241D335BF24E0000000000000000000000004555520000000000B5F762798A53D543A014CAF8B297CFF8F2F937E86540000000000000D5684000000000000315E1'); + types.Object.serialize(so, { + TakerPays: '87654321.12345678/EUR/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', + TakerGets: '213', + Fee: 789 + }); + assert.strictEqual(so.to_hex(), '64D65F241D335BF24E0000000000000000000000004555520000000000B5F762798A53D543A014CAF8B297CFF8F2F937E86540000000000000D5684000000000000315E1'); //TODO: Check independently. }); it('Parse same object', function () { var so = new SerializedObject('64D65F241D335BF24E0000000000000000000000004555520000000000B5F762798A53D543A014CAF8B297CFF8F2F937E86540000000000000D5684000000000000315E1'); var parsed_object=types.Object.parse(so); - assert.equals(parsed_object, - { TakerPays: - { _value: { '0': 56357454, '1': 32653779, t: 2, s: 0 }, - _offset: -8, - _is_native: false, - _is_negative: false, - _currency: { _value: 'EUR' }, - _issuer: { _value: -422657445385694440895149034202122766475892017176 } }, - TakerGets: - { _value: { '0': 213, '1': 0, '2': 0, t: 1, s: 0 }, - _offset: 0, - _is_native: true, - _is_negative: false, - _currency: { _value: NaN }, - _issuer: { _value: NaN } }, - Fee: - { _value: { '0': 789, '1': 0, '2': 0, t: 1, s: 0 }, - _offset: 0, - _is_native: true, - _is_negative: false, - _currency: { _value: NaN }, - _issuer: { _value: NaN } } } - ); - //TODO: Check independently. + assert.deepEqual(parsed_object, { + TakerPays: { + _value: { '0': 56357454, '1': 32653779, t: 2, s: 0 }, + _offset: -8, + _is_native: false, + _is_negative: false, + _currency: { _value: 'EUR' }, + _issuer: { _value: -422657445385694440895149034202122766475892017176 } }, + TakerGets: { + _value: { '0': 213, '1': 0, '2': 0, t: 1, s: 0 }, + _offset: 0, + _is_native: true, + _is_negative: false, + _currency: { _value: NaN }, + _issuer: { _value: NaN } + }, + Fee: { + _value: { '0': 789, '1': 0, '2': 0, t: 1, s: 0 }, + _offset: 0, + _is_native: true, + _is_negative: false, + _currency: { _value: NaN }, + _issuer: { _value: NaN } + } + }); + //TODO: Check independently. }); it('Serialize simple object {DestinationTag:123, QualityIn:456, QualityOut:789}', function () { var so = new SerializedObject(); types.Object.serialize(so, {DestinationTag:123, QualityIn:456, QualityOut:789}); //console.log('DOES THE JSON METHOD WORK?', so.to_json()); - assert.equals(so.to_hex(), '2E0000007B2014000001C8201500000315E1'); + assert.strictEqual(so.to_hex(), '2E0000007B2014000001C8201500000315E1'); //TODO: Check independently. }); it('Parse simple object {DestinationTag:123, QualityIn:456, QualityOut:789}', function () { //2E0000007B22000001C82400000315E1 2E0000007B2002000001C8200200000315E1 var so = new SerializedObject('2E0000007B2014000001C8201500000315E1'); var parsed_object=types.Object.parse(so); - assert.equals(parsed_object,{DestinationTag:123, QualityIn:456, QualityOut:789}); + assert.deepEqual(parsed_object, { DestinationTag:123, QualityIn:456, QualityOut:789 }); //TODO: Check independently. }); }); @@ -523,38 +555,43 @@ describe('Serialized types', function() { it('Serialize empty array []', function () { var so = new SerializedObject(); types.Array.serialize(so, []); - assert.equals(so.to_hex(), 'F1'); + assert.strictEqual(so.to_hex(), 'F1'); }); it('Parse empty array []', function () { var so = new SerializedObject('F1'); var parsed_object=types.Array.parse(so); - assert.equals(parsed_object,[]); + assert.deepEqual(parsed_object, []); }); it('Serialize 3-length array [{TakerPays:123}); {TakerGets:456}, {Fee:789}]', function () { var so = new SerializedObject(); types.Array.serialize(so, [{TakerPays:123}, {TakerGets:456}, {Fee:789}]); //TODO: Check this manually - - assert.equals(so.to_hex(), '64400000000000007B6540000000000001C8684000000000000315F1'); + assert.strictEqual(so.to_hex(), '64400000000000007B6540000000000001C8684000000000000315F1'); }); it('Parse the same array', function () { var so = new SerializedObject('64400000000000007B6540000000000001C8684000000000000315F1'); var parsed_object=types.Array.parse(so); //console.log('WE GOT:', parsed_object[0].TakerPays._value, parsed_object[1].TakerGets._value, parsed_object[2].Fee._value); - assert.equals([123,456,789],[parsed_object[0].TakerPays._value, parsed_object[1].TakerGets._value, parsed_object[2].Fee._value]); + assert.strictEqual([123,456,789],[ + parsed_object[0].TakerPays._value, + parsed_object[1].TakerGets._value, + parsed_object[2].Fee._value]); }); it('Serialize 3-length array [{DestinationTag:123}); {QualityIn:456}, {Fee:789}]', function () { var so = new SerializedObject(); types.Array.serialize(so, [{DestinationTag:123}, {QualityIn:456}, {Fee:789}]); //TODO: Check this manually //console.log('DOES THE JSON METHOD WORK2?', so.to_json()); - assert.equals(so.to_hex(), '2E0000007B2014000001C8684000000000000315F1'); + assert.strictEqual(so.to_hex(), '2E0000007B2014000001C8684000000000000315F1'); }); it('Parse the same array 2', function () { var so = new SerializedObject('2E0000007B2014000001C8684000000000000315F1'); var parsed_object=types.Array.parse(so); //TODO: Is this correct? Return some things as integers, and others as objects? - assert.equals([123,456,789],[parsed_object[0].DestinationTag, parsed_object[1].QualityIn, parsed_object[2].Fee._value]); + assert.deepEqual([123,456,789],[ + parsed_object[0].DestinationTag, + parsed_object[1].QualityIn, + parsed_object[2].Fee._value]); }); }); });