public virtual void ShouldDecodeNegativeByteArray() { IntType intType = new IntType("int"); var bytes = intType.Encode(-100000569); var result = intType.Decode<BigInteger>(bytes); Assert.Equal(new BigInteger(-100000569), result); }
public virtual void ShouldEncodeUInt() { IntType intType = new IntType("uint"); uint given = 1234567; var result = intType.Encode(given).ToHex(); Assert.Equal("000000000000000000000000000000000000000000000000000000000012d687", result); }
public virtual void ShouldEncodeDecodeInt() { var intType = new IntType("int"); var result = intType.Encode(int.MaxValue).ToHex(); var intresult = intType.Decode <int>(result); Assert.Equal(int.MaxValue, intresult); }
public virtual void ShouldEncodeDecodeSByte() { var intType = new IntType("int8"); var result = intType.Encode(sbyte.MaxValue).ToHex(); var intresult = intType.Decode <sbyte>(result); Assert.Equal(sbyte.MaxValue, intresult); }
public virtual void ShouldThrowErrorWhenEncodingExceedingIntMaxValue() { var intType = new IntType("int"); var given = IntType.MAX_INT256_VALUE + 1; var ex = Assert.Throws <ArgumentOutOfRangeException>("value", () => intType.Encode(given)); Assert.StartsWith("Signed SmartContract integer must not exceed maximum value for int256", ex.Message); }
public virtual void ShouldEncodeDecodeUInt64() { var intType = new IntType("uint64"); var result = intType.Encode(ulong.MaxValue).ToHex(); var intresult = intType.Decode <ulong>(result); Assert.Equal(ulong.MaxValue, intresult); }
public virtual void ShouldEncodeDecodeUShort() { var intType = new IntType("uint16"); var result = intType.Encode(ushort.MaxValue).ToHex(); var intresult = intType.Decode <ushort>(result); Assert.Equal(ushort.MaxValue, intresult); }
public virtual void ShouldEncodeUInt() { var intType = new IntType("uint"); uint given = 1234567; var result = intType.Encode(given).ToHex(); Assert.Equal("000000000000000000000000000000000000000000000000000000000012d687", result); }
public virtual void ShouldDecodeNegativeByteArray() { var intType = new IntType("int"); var bytes = intType.Encode(-100000569); var result = intType.Decode <BigInteger>(bytes); Assert.Equal(new BigInteger(-100000569), result); }
public virtual void ShouldThrowErrorWhenEncodingIsLessThanIntMinValue() { var intType = new IntType("int"); var given = IntType.MIN_INT256_VALUE - 1; var ex = Assert.Throws <ArgumentOutOfRangeException>("value", () => intType.Encode(given)); Assert.StartsWith($"Signed SmartContract integer must not be less than the minimum value for int256", ex.Message); }
public virtual void ShouldEncodeDecodeEnum() { var intType = new IntType("int"); var result1 = intType.Encode(TestEnum.Monkey).ToHex(); var decresult1 = intType.Decode <TestEnum>(result1); Assert.Equal(TestEnum.Monkey, decresult1); var result2 = intType.Encode(TestEnum.Elephant).ToHex(); var decresult2 = intType.Decode <TestEnum>(result2); Assert.Equal(TestEnum.Elephant, decresult2); var result3 = intType.Encode(TestEnum.Lion).ToHex(); var decresult3 = intType.Decode <TestEnum>(result3); Assert.Equal(TestEnum.Lion, decresult3); }
public virtual void ShouldThrowErrorWhenValueIsNull() { var intType = new IntType("int"); object given = null; var ex = Assert.Throws <Exception>(() => intType.Encode(given)); Assert.Equal("Invalid value for type 'Nethereum.ABI.Encoders.IntTypeEncoder'. Value: null, ValueType: ()", ex.Message); }
public virtual void ShouldEncodeInt() { IntType intType = new IntType("int"); var result = intType.Encode(69).ToHex(); Assert.Equal("0000000000000000000000000000000000000000000000000000000000000045", result); }
public virtual void ShouldEncodeNegativeInt() { IntType intType = new IntType("int"); var result = intType.Encode(-1234567).ToHex(); Assert.Equal("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed2979", result); }
public virtual void ShouldEncodeStrings() { IntType intType = new IntType("int"); var result2 = intType.Encode("1234567890abcdef1234567890abcdef12345678").ToHex(); Assert.Equal("0000000000000000000000001234567890abcdef1234567890abcdef12345678", result2); }
public virtual void ShouldEncode(string value, string hexExpected) { IntType intType = new IntType("int"); var result = intType.Encode(BigInteger.Parse(value)); Assert.Equal(hexExpected, "0x" + result.ToHex()); }
public virtual void ShouldThrowErrorWhileEncodeLargeInt() { const int maxIntSizeInBytes = 32; var intType = new IntType("uint"); var given = new BigInteger(Enumerable.Range(1, maxIntSizeInBytes + 1).Select(x => (byte)x).ToArray()); var ex = Assert.Throws <ArgumentOutOfRangeException>("value", () => intType.Encode(given)); Assert.StartsWith($"Integer value must not exceed maximum Solidity size of {maxIntSizeInBytes} bytes", ex.Message); }