测试

Author: masx200

pom.xml

@@ -190,6 +190,11 @@
     </build>
 
     <dependencies>
+        <dependency>
+            <groupId>com.alibaba.fastjson2</groupId>
+            <artifactId>fastjson2-kotlin</artifactId>
+            <version>2.0.21</version>
+        </dependency>
         <dependency>
             <groupId>com.github.masx200</groupId>
             <artifactId>leetcode-treenode-java</artifactId>
@@ -220,6 +225,12 @@
             <version>1.4.1</version>
 
         </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-reflect</artifactId>
+            <version>1.7.21</version>
+            <scope>compile</scope>
+        </dependency>
 
 
     </dependencies>

test/com/github/masx200/leetcode_test/operations_lcci/OperationsTest.kt

@@ -1,6 +1,12 @@
 package com.github.masx200.leetcode_test.operations_lcci
 
+import com.alibaba.fastjson2.JSON
+import com.alibaba.fastjson2.JSONArray
+import com.github.masx200.leetcode_test.utils.runScript
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
 import org.junit.jupiter.api.Test
+import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
 
 class OperationsTest {
@@ -15,6 +21,66 @@ class OperationsTest {
 
     @Test
     fun multiply() {
+
+        val actual: JSONArray = JSON.parseArray(
+            """
+[
+                null,
+                2147483647,
+                -2147483648,
+                2147483647,
+                -2147483600,
+                -2147483647,
+                -2147483648
+            ]
+"""
+        )
+        val expected: List<Any?> = runScript(
+            Json.decodeFromString(
+                """
+[
+                    "Operations",
+                    "minus",
+                    "minus",
+                    "multiply",
+                    "multiply",
+                    "divide",
+                    "divide"
+]
+                """
+            ),
+            JSON.parseArray(
+                """
+[
+                    [],
+                    [0, -2147483647],
+                    [-1, 2147483647],
+                    [-1, -2147483647],
+                    [-100, 21474836],
+                    [2147483647, -1],
+                    [-2147483648, 1]
+                ]
+"""
+            ) as ArrayList<ArrayList<Any>>,
+            Operations::class,
+        )
+        println("expected")
+        expected.forEach {
+            if (it != null) {
+                println(it.javaClass)
+            }
+        }
+        println("actual")
+        actual.forEach {
+            if (it != null) {
+                println(it.javaClass)
+            }
+        }
+        assertContentEquals(
+
+            expected,
+            actual,
+        );
     }
 
 

utils/runScript.kt

@@ -1,3 +1,68 @@
 package com.github.masx200.leetcode_test.utils
 
-fun runScript(){}
+import kotlin.reflect.KClass
+import kotlin.reflect.KFunction
+import kotlin.reflect.full.declaredFunctions
+import kotlin.reflect.jvm.jvmName
+
+fun runScript(commands: List<String>, inputs: ArrayList<ArrayList<Any>>, classes: KClass<*>): List<Any?> {
+//    println(commands)
+//    println(inputs)
+//    println(classes)
+    val kFunction = classes.constructors.first()
+    if (kFunction.parameters.size != inputs[0].size) throw Error("constructor parameters mismatch")
+//    println(kFunction.parameters)
+    val instance = kFunction.call(*Array(inputs[0].size) { inputs[0][it] })
+    val res = List<Any?>(commands.size) { null }.toMutableList()
+    val methodMap = hashMapOf<String, KFunction<*>>()
+    for (fu in classes.declaredFunctions) {
+
+        methodMap[fu.name] = fu
+    }
+//    println(instance)
+    for ((i, arg) in inputs.withIndex()) {
+        if (i != 0) {
+            val name = commands[i]
+            val fu = methodMap[name] ?: throw Error("method not found")
+//            (fu.parameters).forEach(::println)
+//            println(arg[0].javaClass)
+
+            for (j in arg.indices) {
+                if (arg[j].javaClass != (fu.parameters[j + 1].type.classifier) as KClass<*>) {
+                    val jvmName = (fu.parameters[j + 1].type.classifier as KClass<*>).jvmName
+                    val old = arg[j]
+                    if (old is Number) {
+                        arg[j] = when (jvmName) {
+                            "int" -> old.toInt()
+                            "double" -> old.toDouble()
+                            "float" -> old.toFloat()
+                            "long" -> old.toLong()
+                            "char" -> old.toChar()
+                            "short" -> old.toShort()
+                            "byte" -> old.toByte()
+                            else -> {
+                                throw Error("error number type:" + jvmName)
+                            }
+                        }
+                    }
+//                    println(arg[j].javaClass.name)
+
+//                    println(jvmName)
+
+//                    println(arg[j] is Number)
+                }
+            }
+
+            val re = fu.call(instance, *Array(arg.size) { arg[it] })
+
+            if (re == Unit) {
+                res[i] = null
+            } else {
+                res[i] = re
+            }
+        }
+
+    }
+
+    return res
+}