Fix problem in handling normal cast

Author: mksong76

unittest/src/main/java/score/Context.java

@@ -92,7 +92,7 @@ public static<T> T call(Class<T> cls, BigInteger value,
 
     public static Object call(BigInteger value,
                               Address targetAddress, String method, Object... params) {
-        return TypeConverter.normalize(sm.call(value, targetAddress, method, params));
+        return TypeConverter.cast(sm.call(value, targetAddress, method, params));
     }
 
     public static<T> T call(Class<T> cls,
@@ -101,7 +101,7 @@ public static<T> T call(Class<T> cls,
     }
 
     public static Object call(Address targetAddress, String method, Object... params) {
-        return TypeConverter.normalize(sm.call(BigInteger.ZERO, targetAddress, method, params));
+        return TypeConverter.cast(sm.call(BigInteger.ZERO, targetAddress, method, params));
     }
 
     public static void transfer(Address targetAddress, BigInteger value) {

unittest/src/main/java/score/ServiceManagerImpl.java

@@ -608,7 +608,7 @@ private static Object[] convertParameters(Method method, Object[] params) {
                 parsedParams[i] = null;
             } else {
                 try {
-                    parsedParams[i] = TypeConverter.parameterize(params[i], parameterClass);
+                    parsedParams[i] = TypeConverter.cast(params[i], parameterClass);
                 } catch (RuntimeException e) {
                     throw new IllegalArgumentException(
                             String.format("InvalidParameter(idx=%d,target=%s,source=%s)",

unittest/src/main/java/score/impl/TypeConverter.java

@@ -32,8 +32,8 @@
 import java.util.Map;
 
 public class TypeConverter {
-    public static Object normalize(Object so) {
-        return normalize(so, true);
+    private static Object normalize(Object so) {
+        return normalize(so, false);
     }
 
     private static Object normalize(Object so, boolean ret) {
@@ -201,9 +201,8 @@ public static<T> T cast(Object so, Class<T> cls) {
         return (T)specialize(normalize(so), cls);
     }
 
-    @SuppressWarnings("unchecked")
-    public static<T> T parameterize(Object so, Class<T> cls) {
-        return (T)specialize(normalize(so, false), cls);
+    public static Object cast(Object so) {
+        return normalize(so, true);
     }
 
     @SuppressWarnings("unchecked")

unittest/src/test/java/score/impl/TypeConverterTest.java

@@ -68,7 +68,8 @@ void normalizeList() {
                 new Address[]{Address.fromString("hx0800000000000000000000000000000000000000")}
         };
         for (var tc : cases) {
-            assertDoesNotThrow(() -> (List<Object>) TypeConverter.normalize(tc));
+            //noinspection unchecked
+            assertDoesNotThrow(() -> (List<Object>) TypeConverter.cast(tc));
         }
     }
 
@@ -80,7 +81,8 @@ void normalizeMap() {
                 Map.of("a", List.of(Map.of("a", BigInteger.ZERO)))
         };
         for (var tc : cases) {
-            assertDoesNotThrow(() -> (Map<String, Object>) TypeConverter.normalize(tc));
+            //noinspection unchecked
+            assertDoesNotThrow(() -> (Map<String, Object>) TypeConverter.cast(tc));
         }
     }
 
@@ -128,4 +130,21 @@ void objectStore() {
             assertEquals(tc, obj);
         }
     }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    void arrayTo() {
+        var value = new int[]{ 1, 2, 3};
+
+        var arrayValue = TypeConverter.cast(value, long[].class);
+        assertArrayEquals(new long[]{ 1, 2, 3}, arrayValue);
+
+        var listValue = TypeConverter.cast(value);
+        var realValue = (List<BigInteger>)listValue;
+        int idx = 0;
+        for (var v : realValue) {
+            assertEquals(value[idx], v.intValueExact());
+            idx+=1;
+        }
+    }
 }