aboutsummaryrefslogtreecommitdiffstats
path: root/packages
diff options
context:
space:
mode:
authorGreg Hysen <greg.hysen@gmail.com>2018-11-20 03:47:32 +0800
committerGreg Hysen <greg.hysen@gmail.com>2018-11-29 08:38:10 +0800
commit666075a87e8f7dfd5ef3553c5f8e08d826ac0641 (patch)
treec69d89488ec58c6726cf7ae498b83b6f1ef8f9d4 /packages
parentb28f26916fc51fa13308f335e3cd0bd5d3b075fc (diff)
downloaddexon-0x-contracts-666075a87e8f7dfd5ef3553c5f8e08d826ac0641.tar.gz
dexon-0x-contracts-666075a87e8f7dfd5ef3553c5f8e08d826ac0641.tar.zst
dexon-0x-contracts-666075a87e8f7dfd5ef3553c5f8e08d826ac0641.zip
Tests for Integer (tested 256 / 32 bit integers)
Diffstat (limited to 'packages')
-rw-r--r--packages/utils/src/abi_encoder/evm_data_types.ts4
-rw-r--r--packages/utils/test/abi_encoder_test.ts202
2 files changed, 180 insertions, 26 deletions
diff --git a/packages/utils/src/abi_encoder/evm_data_types.ts b/packages/utils/src/abi_encoder/evm_data_types.ts
index 1ee95863b..38878f63e 100644
--- a/packages/utils/src/abi_encoder/evm_data_types.ts
+++ b/packages/utils/src/abi_encoder/evm_data_types.ts
@@ -118,9 +118,9 @@ abstract class Number extends PayloadDataType {
public encodeValue(value_: BigNumber | string | number): Buffer {
const value = new BigNumber(value_, 10);
if (value.greaterThan(this.getMaxValue())) {
- throw `tried to assign value of ${value}, which exceeds max value of ${this.getMaxValue()}`;
+ throw `Tried to assign value of ${value}, which exceeds max value of ${this.getMaxValue()}`;
} else if (value.lessThan(this.getMinValue())) {
- throw `tried to assign value of ${value}, which exceeds min value of ${this.getMinValue()}`;
+ throw `Tried to assign value of ${value}, which exceeds min value of ${this.getMinValue()}`;
}
const hexBase = 16;
diff --git a/packages/utils/test/abi_encoder_test.ts b/packages/utils/test/abi_encoder_test.ts
index 123ebe11d..21ad89711 100644
--- a/packages/utils/test/abi_encoder_test.ts
+++ b/packages/utils/test/abi_encoder_test.ts
@@ -932,40 +932,194 @@ describe.only('ABI Encoder', () => {
});
});
- /*
- describe('Integer', () => {
- const testIntDataItem = { name: 'testInt', type: 'int' };
- it('Positive - Base case', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(1));
- const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ describe.only('Integer', () => {
+ it('Int256 - Positive Base Case', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (256)', type: 'int' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const args = new BigNumber(1);
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0x0000000000000000000000000000000000000000000000000000000000000001';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
});
- it('Positive', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(437829473));
- const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ it('Int256 - Negative Base Case', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (256)', type: 'int' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const args = new BigNumber(-1);
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
});
- it('Negative - Base case', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(-1));
- const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ it('Int256 - Positive Value', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (256)', type: 'int' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const max256BitInteger = (new BigNumber(2)).pow(255).minus(1);
+ const args = max256BitInteger;
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
});
- it('Negative', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(-437829473));
- const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ it('Int256 - Negative Value', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (256)', type: 'int' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const min256BitInteger = (new BigNumber(2)).pow(255).times(-1);
+ const args = min256BitInteger;
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = `0x8000000000000000000000000000000000000000000000000000000000000000`;
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
});
- // TODO: Add bounds tests + tests for different widths
+ it('Int256 - Value too large', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (256)', type: 'int' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const max256BitInteger = (new BigNumber(2)).pow(255).minus(1);
+ const args = max256BitInteger.plus(1);
+ // Encode Args and validate result
+ expect(() => { dataType.encode(args) }).to.throw();
+ });
+
+ it('Int256 - Value too small', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (256)', type: 'int' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const min256BitInteger = (new BigNumber(2)).pow(255).times(-1);
+ const args = min256BitInteger.minus(1);
+ // Encode Args and validate result
+ expect(() => { dataType.encode(args) }).to.throw();
+ });
+
+ it('Int32 - Positive Base Case', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (32)', type: 'int32' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const args = new BigNumber(1);
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0x0000000000000000000000000000000000000000000000000000000000000001';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
+ });
+
+ it('Int32 - Negative Base Case', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (32)', type: 'int32' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const args = new BigNumber(-1);
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
+ });
+
+ it('Int32 - Positive Value', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (32)', type: 'int32' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const max32BitInteger = (new BigNumber(2)).pow(31).minus(1);
+ const args = max32BitInteger;
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0x000000000000000000000000000000000000000000000000000000007fffffff';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
+ });
+
+ it('Int32 - Negative Value', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (32)', type: 'int32' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const min32BitInteger = (new BigNumber(2)).pow(31).times(-1);
+ const args = min32BitInteger;
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = `0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000`;
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
+ });
+
+ it('Int32 - Value too large', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (32)', type: 'int32' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const max32BitInteger = (new BigNumber(2)).pow(31).minus(1);
+ const args = max32BitInteger.plus(1);
+ // Encode Args and validate result
+ expect(() => { dataType.encode(args) }).to.throw();
+ });
+
+ it('Int32 - Value too small', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'Integer (32)', type: 'int32' };
+ const dataType = new AbiEncoder.Int(testDataItem);
+ // Construct args to be encoded
+ const min32BitInteger = (new BigNumber(2)).pow(31).times(-1);
+ const args = min32BitInteger.minus(1);
+ // Encode Args and validate result
+ expect(() => { dataType.encode(args) }).to.throw();
+ });
});
+ /*
+
describe('Unsigned Integer', () => {
const testIntDataItem = { name: 'testUInt', type: 'uint' };
it('Lower Bound', async () => {