add ut for scale integer (#420)

cyjseagull · web-flow · commit 51bb4487e262 · 2021-11-29T19:22:51.000+08:00
* add ut for scale integer

* add address encode/decode
diff --git a/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/datatypes/IntType.java b/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/datatypes/IntType.java
@@ -9,22 +9,20 @@ public IntType(String typePrefix, int bitSize, BigInteger value) {
         super(typePrefix + bitSize, value, bitSize);
         if (!valid(bitSize, value)) {
             throw new UnsupportedOperationException(
-                    "Bitsize must be 8 bit aligned, and in range 0 < bitSize <= 256, and in valid range, bitSize: "
+                    "Bit size must be 8 bit aligned, and the bitLength must be no larger than "
                             + bitSize
+                            + ". Current bytes size:"
+                            + value.toByteArray().length
                             + ", value:"
                             + value);
         }
     }
 
     boolean valid(int bitSize, BigInteger value) {
-        return isValidBitSize(bitSize) && isValidBitCount(bitSize, value);
+        return isValidBitSize(bitSize);
     }
 
     static boolean isValidBitSize(int bitSize) {
         return bitSize % 8 == 0 && bitSize > 0 && bitSize <= MAX_BIT_LENGTH;
     }
-
-    private static boolean isValidBitCount(int bitSize, BigInteger value) {
-        return value.bitLength() <= bitSize;
-    }
 }
diff --git a/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/ScaleCodecReader.java b/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/ScaleCodecReader.java
@@ -79,23 +79,22 @@ public BigInteger decodeInteger(boolean signed, int bytesSize) {
         }
         byte[] resultBytes = readByteArray(bytesSize);
         ArrayUtils.reverse(resultBytes);
-        int pos = 0;
-        for (; pos < resultBytes.length; pos++) {
-            if (resultBytes[pos] != 0) {
-                break;
-            }
-        }
-        int length = resultBytes.length - pos;
-        byte[] result = new byte[length];
-        System.arraycopy(resultBytes, pos, result, 0, length);
-        BigInteger value = new BigInteger(result);
+        BigInteger value = new BigInteger(resultBytes);
         if (value.compareTo(BigInteger.ZERO) < 0 && signed == false) {
             BigInteger minOverflowUnsignedValue = BigInteger.valueOf((1 << (bytesSize * 8)));
             return value.add(minOverflowUnsignedValue);
         }
         return value;
     }
 
+    public BigInteger decodeInt256() {
+        if (hasMore(32) == false) {
+            throw new UnsupportedOperationException("decodeInt256 exception for not enough data");
+        }
+        byte[] data = readByteArray(32);
+        return new BigInteger(data);
+    }
+
     public BigInteger decodeCompactInteger() {
         byte firstByte = readByte();
         int flag = ((int) (firstByte) & 0b00000011);
diff --git a/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/ScaleCodecWriter.java b/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/ScaleCodecWriter.java
@@ -76,13 +76,14 @@ private void encodeThirdCategory(BigInteger value) throws IOException {
     }
 
     public void writeUnsignedInteger(BigInteger value, int valueByteSize) throws IOException {
-        BigInteger maxSignedValue = BigInteger.valueOf((1 << (valueByteSize * 8 - 1)) - 1);
+        BigInteger maxSignedValue =
+                BigInteger.ONE.shiftLeft((valueByteSize * 8 - 1)).subtract(BigInteger.ONE);
         if (value.compareTo(maxSignedValue) <= 0) {
             writeInteger(value, valueByteSize);
             return;
         }
         // the highest bit is 1, convert to the negative
-        BigInteger minOverflowUnsignedValue = BigInteger.valueOf((1 << (valueByteSize * 8)));
+        BigInteger minOverflowUnsignedValue = BigInteger.ONE.shiftLeft(valueByteSize * 8);
         if (value.compareTo(minOverflowUnsignedValue) >= 0) {
             throw new UnsupportedOperationException(
                     "writeInteger exception for overflow, value: " + value);
@@ -100,12 +101,44 @@ public void writeInteger(BigInteger value, int valueByteSize) throws IOException
             throw new UnsupportedOperationException(
                     "writeInteger exception for overflow, value: " + value);
         }
+
         for (int i = 0; i < byteValue.length; ++i) {
             byteArray[i] = byteValue[byteValue.length - i - 1];
         }
+        // negative value(fill 0xff: -1)
+        if (value.compareTo(BigInteger.ZERO) < 0) {
+            for (int i = byteValue.length; i < valueByteSize; i++) {
+                byteArray[i] = (byte) 0xff;
+            }
+        }
         writeByteArray(byteArray);
     }
 
+    public void writeBigInt256(boolean signed, BigInteger value) throws IOException {
+        if (value.compareTo(BigInteger.ZERO) < 0 && !signed) {
+            throw new UnsupportedOperationException(
+                    "Must provide positive data when using unsigned type");
+        }
+        // get bytes size
+        byte[] valueBytes = value.toByteArray();
+        byte size = (byte) (valueBytes.length);
+        // when byteSize more than 16, encode as u256
+        if (size > 32) {
+            throw new UnsupportedOperationException(
+                    "Unsupported unsigned type with length more than 32 bytes");
+        }
+        byte[] encodedData = new byte[32];
+        System.arraycopy(valueBytes, 0, encodedData, (32 - valueBytes.length), valueBytes.length);
+        // extend 0xff
+        if (signed && value.compareTo(BigInteger.ZERO) < 0) {
+            for (int i = 0; i < (32 - valueBytes.length); i++) {
+                encodedData[i] = (byte) 0xff;
+            }
+        }
+        // write the big-endian data
+        writeByteArray(encodedData);
+    }
+
     private void writeSecondCategory(BigInteger value) throws IOException {
         // only values from [kMinUint16, kMinUint32) can be put here
         long v = value.longValue();
diff --git a/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/TypeDecoder.java b/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/TypeDecoder.java
@@ -12,6 +12,7 @@
 import java.util.function.BiFunction;
 import org.fisco.bcos.sdk.codec.Utils;
 import org.fisco.bcos.sdk.codec.datatypes.*;
+import org.fisco.bcos.sdk.codec.datatypes.generated.Uint160;
 
 public class TypeDecoder {
     @SuppressWarnings("unchecked")
@@ -20,6 +21,8 @@ public static <T extends Type> T decode(ScaleCodecReader reader, Class<T> type)
             return (T) decodeNumeric(reader, (Class<NumericType>) type);
         } else if (Bool.class.isAssignableFrom(type)) {
             return (T) decodeBool(reader);
+        } else if (Address.class.isAssignableFrom(type)) {
+            return (T) decodeAddress(reader);
         } else if (Bytes.class.isAssignableFrom(type)
                 || DynamicBytes.class.isAssignableFrom(type)) {
             return (T) decodeBytes(reader, (Class<Bytes>) type);
@@ -39,6 +42,10 @@ public static <T extends Type> T decode(ScaleCodecReader reader, Class<T> type)
         }
     }
 
+    public static Address decodeAddress(ScaleCodecReader reader) {
+        return new Address(decodeNumeric(reader, Uint160.class));
+    }
+
     public static <T extends NumericType> T decodeNumeric(ScaleCodecReader reader, Class<T> type) {
         try {
             int bitSize = 256;
@@ -69,7 +76,7 @@ public static <T extends NumericType> T decodeNumeric(ScaleCodecReader reader, C
             if (bytesSize >= 1 && bytesSize <= 16) {
                 value = reader.decodeInteger(signedValue, bytesSize);
             } else {
-                value = reader.decodeCompactInteger();
+                value = reader.decodeInt256();
             }
             return type.getConstructor(BigInteger.class).newInstance(value);
         } catch (NoSuchMethodException
diff --git a/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/TypeEncoder.java b/sdk-codec/src/main/java/org/fisco/bcos/sdk/codec/scale/TypeEncoder.java
@@ -13,6 +13,8 @@ public static void encode(Type parameter, ScaleCodecWriter writer) throws IOExce
             encodeBool((Bool) parameter, writer);
         } else if (parameter instanceof BytesType) {
             encodeBytes((BytesType) parameter, writer);
+        } else if (parameter instanceof Address) {
+            encodeAddress((Address) parameter, writer);
         } else if (parameter instanceof Utf8String) {
             encodeString((Utf8String) parameter, writer);
         } else if (parameter instanceof StructType) {
@@ -25,20 +27,24 @@ public static void encode(Type parameter, ScaleCodecWriter writer) throws IOExce
         }
     }
 
+    public static void encodeAddress(Address address, ScaleCodecWriter writer) throws IOException {
+        encodeNumeric(address.toUint160(), writer);
+    }
+
     public static void encodeNumeric(NumericType numericType, ScaleCodecWriter writer)
             throws IOException {
         int bitSize = numericType.getBitSize();
         int byteSize = bitSize / 8;
+        boolean signedInteger = (numericType.getTypeAsString().contains("uint")) ? false : true;
         if (byteSize >= 1 && byteSize <= 16) {
-            if (numericType.getTypeAsString().contains("uint")) {
+            if (!signedInteger) {
                 writer.writeUnsignedInteger(numericType.getValue(), byteSize);
                 return;
             }
             writer.writeInteger(numericType.getValue(), byteSize);
             return;
         }
-        // Note: modify with liquid u256 after modify the node
-        writer.writeCompactInteger(numericType.getValue());
+        writer.writeBigInt256(signedInteger, numericType.getValue());
     }
 
     public static void encodeBool(Bool boolType, ScaleCodecWriter writer) throws IOException {
diff --git a/sdk-codec/src/test/java/org/fisco/bcos/sdk/codec/scale/ScaleTest.java b/sdk-codec/src/test/java/org/fisco/bcos/sdk/codec/scale/ScaleTest.java

Original file line number	Diff line number	Diff line change
`@@ -9,22 +9,20 @@ public IntType(String typePrefix, int bitSize, BigInteger value) {`
`9`	`9`	`super(typePrefix + bitSize, value, bitSize);`
`10`	`10`	`if (!valid(bitSize, value)) {`
`11`	`11`	`throw new UnsupportedOperationException(`
`12`		`- "Bitsize must be 8 bit aligned, and in range 0 < bitSize <= 256, and in valid range, bitSize: "`
	`12`	`+ "Bit size must be 8 bit aligned, and the bitLength must be no larger than "`
`13`	`13`	`+ bitSize`
	`14`	`+ + ". Current bytes size:"`
	`15`	`+ + value.toByteArray().length`
`14`	`16`	`+ ", value:"`
`15`	`17`	`+ value);`
`16`	`18`	`}`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`boolean valid(int bitSize, BigInteger value) {`
`20`		`- return isValidBitSize(bitSize) && isValidBitCount(bitSize, value);`
	`22`	`+ return isValidBitSize(bitSize);`
`21`	`23`	`}`
`22`	`24`
`23`	`25`	`static boolean isValidBitSize(int bitSize) {`
`24`	`26`	`return bitSize % 8 == 0 && bitSize > 0 && bitSize <= MAX_BIT_LENGTH;`
`25`	`27`	`}`
`26`		`-`
`27`		`- private static boolean isValidBitCount(int bitSize, BigInteger value) {`
`28`		`- return value.bitLength() <= bitSize;`
`29`		`- }`
`30`	`28`	`}`