refactor: result and exc will be saved in statement

Author: williamfzc

randunit-android/src/main/java/com/williamfzc/randunit/exceptions/RUInstanceException.kt

@@ -17,4 +17,4 @@
 
 package com.williamfzc.randunit.exceptions
 
-class RUInstanceException(reason: String) : RUException(reason)
+class RUInstanceException(reason: String) : RUException(reason)

randunit/src/main/kotlin/com/williamfzc/randunit/env/AbstractTestEnv.kt

@@ -20,11 +20,14 @@ import com.williamfzc.randunit.env.strategy.AbstractStrategy
 import com.williamfzc.randunit.models.MockModel
 import com.williamfzc.randunit.models.StatementModel
 
-// env was designed for running inside something like TestCase/TestSuite
-// which can be used by different runner
-// it manages:
-// - statement model (s)
-// - about how to gen runnable statement from statement model
+/*
+package `env` contains multiple parts
+- env: used by junit directly, managing everything, making them work together
+- strategy: statement model -> statement s
+- statement: a ready-to-run statement, which contains some real values
+- sandbox: actual statement runner, invoking and suppressing some specific errors provided by rules
+- rules: check if this exception should be thrown
+ */
 abstract class AbstractTestEnv @JvmOverloads constructor(var envConfig: EnvConfig = EnvConfig()) {
     var mockModel = MockModel(envConfig.mockConfig)
     private val strategy: AbstractStrategy by lazy {

randunit/src/main/kotlin/com/williamfzc/randunit/env/NormalTestEnv.kt

@@ -15,8 +15,6 @@
  */
 package com.williamfzc.randunit.env
 
-import com.williamfzc.randunit.exceptions.RUTypeException
-import java.lang.reflect.Method
 import java.util.logging.Logger
 
 open class NormalTestEnv @JvmOverloads constructor(envConfig: EnvConfig = EnvConfig()) :
@@ -30,23 +28,15 @@ open class NormalTestEnv @JvmOverloads constructor(envConfig: EnvConfig = EnvCon
     override fun runStatement(statement: Statement) {
         logger.info("running: ${statement.model.getDesc()}")
 
-        val returnValueOfInvoke = synchronized(statement) {
-            try {
-                statement.invoke()
-            } finally {
-                statement.model.callerOperation.tearDown(statement.caller)
-            }
-        }
+        synchronized(statement) {
+            statement.invoke()
+            statement.model.callerOperation.tearDown(statement.caller)
 
-        returnValueOfInvoke?.let { v ->
-            verifyReturnValue(v, statement.method)
-        }
-    }
+            // handled by sandbox
+            if (statement.isErrorHappened())
+                throw statement.throwExc!!
 
-    private fun verifyReturnValue(v: Any, method: Method) {
-        val retType = v.javaClass
-        val shouldBe = method.returnType.javaClass
-        if (shouldBe.isAssignableFrom(retType))
-            throw RUTypeException("return type $retType != $shouldBe")
+            statement.verifyResult()
+        }
     }
 }

randunit/src/main/kotlin/com/williamfzc/randunit/env/Statement.kt

@@ -15,6 +15,7 @@
  */
 package com.williamfzc.randunit.env
 
+import com.williamfzc.randunit.exceptions.RUVerifyException
 import com.williamfzc.randunit.models.StatementModel
 import java.lang.reflect.Method
 import java.util.logging.Logger
@@ -25,14 +26,27 @@ data class Statement(
     val method: Method,
     val caller: Any,
     val parameters: Collection<Any?>,
-    val model: StatementModel
+    val model: StatementModel,
+    val verifyResult: (Statement) -> String?
 ) {
     companion object {
         private val logger = Logger.getGlobal()
     }
 
+    var executedResult: Any? = null
+    var throwExc: Throwable? = null
+
     fun invoke(): Any? {
-        method.isAccessible = true
-        return method.invoke(caller, *parameters.toTypedArray())
+        try {
+            method.isAccessible = true
+            executedResult = method.invoke(caller, *parameters.toTypedArray())
+        } catch (e: Throwable) {
+            throwExc = e
+        }
+        return executedResult
     }
+
+    fun isErrorHappened() = (null != throwExc)
+
+    fun verifyResult() = verifyResult(this)?.let { throw RUVerifyException(it) }
 }

randunit/src/main/kotlin/com/williamfzc/randunit/env/strategy/NormalStrategy.kt

@@ -22,10 +22,25 @@ import com.williamfzc.randunit.models.StatementModel
 import java.lang.Exception
 import java.util.logging.Logger
 
+fun verifyFunc(s: Statement): String? {
+    s.executedResult?.let {
+        val retType = it.javaClass
+        val shouldBe = s.method.returnType.javaClass
+        if (shouldBe.isAssignableFrom(retType))
+            return "return type $retType != $shouldBe"
+    }
+
+    // can not verify
+    return null
+}
+
 object NormalStrategy : AbstractStrategy() {
     private val logger = Logger.getGlobal()
 
-    override fun genStatements(statementModel: StatementModel, mockModel: MockModel): Iterable<Statement> {
+    override fun genStatements(
+        statementModel: StatementModel,
+        mockModel: MockModel
+    ): Iterable<Statement> {
         // at least it will not cause any crashes because of mock
         var caller = generateCaller(statementModel)
         caller ?: run {
@@ -51,7 +66,15 @@ object NormalStrategy : AbstractStrategy() {
         }
 
         // by default, gen only one statement
-        return setOf(Statement(statementModel.method, caller!!, parameters, statementModel))
+        return setOf(
+            Statement(
+                statementModel.method,
+                caller!!,
+                parameters,
+                statementModel,
+                ::verifyFunc
+            )
+        )
     }
 
     private fun generateCaller(statementModel: StatementModel): Any? {

randunit/src/main/kotlin/com/williamfzc/randunit/exceptions/RUVerifyException.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2021 williamfzc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.williamfzc.randunit.exceptions
+
+class RUVerifyException(reason: String) : RUException(reason)