release v0.6.5

* master:
  update faq about how to mock inner class

.gitignore

@@ -1,5 +1,6 @@
 # maven ignore
 target/
+.mvn/
 
 # gradle ignore
 build/

README.md

@@ -2,16 +2,16 @@
 
 换种思路写Mock，让单元测试更简单。
 
-无需初始化，不挑测试框架，甭管要换的是私有方法、静态方法、构造方法还是其他任何类的任何方法，也甭管要换的对象是怎么创建的。写好Mock定义，加个`@MockMethod`注解，一切统统搞定。
+无需初始化，不挑服务框架，甭管要换的是私有方法、静态方法、构造方法还是其他任何类的任何方法，也甭管要换的对象是怎么创建的。写好Mock定义，加个`@MockMethod`注解，一切统统搞定。
 
 - 文档：https://alibaba.github.io/testable-mock/
 - 国内文档镜像：http://freyrlin.gitee.io/testable-mock/
 
 阅读[这里](https://mp.weixin.qq.com/s/KyU6Eu7mDkZU8FspfSqfMw)了解更多故事。
 
-> 特别说明
-> 1. 如遇到"Attempt to access non-static member in mock method"错误，参见[常见问题](https://alibaba.github.io/testable-mock/#/zh-cn/doc/frequently-asked-questions)第8条
-> 2. 如果有遇到其他任何使用问题和建议，请直接在[Issue](https://github.com/alibaba/testable-mock/issues)中提出，也可通过[Pull Request](https://github.com/alibaba/testable-mock/pulls)提交您的代码，我们将在24小时内回复并处理
+<font size="5">**0.6版本已发布**</font>，从`0.5.x`升级到`0.6.x`版本请参考[版本升级指南](https://alibaba.github.io/testable-mock/#/zh-cn/doc/upgrade-guide)
+
+如果有遇到其他任何使用问题和建议，请直接在[Issues](https://github.com/alibaba/testable-mock/issues)中提出，也可通过[Pull Request](https://github.com/alibaba/testable-mock/pulls)提交您的代码，我们将在24小时内回复并处理
 
 -----
 
@@ -19,9 +19,8 @@
 
 `TestableMock`正在持续迭代演进，以下版本计划可能在开发过程中发生调整
 
-- `0.4` 当前版本，进行中的工作内容参考[Issue](https://github.com/alibaba/testable-mock/issues)清单
-- `0.5` 实现以"独立Mock类"为单元的Mock方法复用机制，让测试类之间可以方便复用相同的Mock方法
-- `0.6` 实现将Mock方法的默认生效范围缩小至当前被测类，避免Mock方法在测试类之间相互影响
+- `0.6` 当前版本，进行中的工作内容参考[Issue](https://github.com/alibaba/testable-mock/issues)清单
+- `0.7` 完善Mock功能的防代码重构机制，支持快速Mock指定类型的所有方法
 - `1.0` 功能稳定，一个崭新的开始
 
 ## 目录结构
@@ -33,6 +32,7 @@
 |-- testable-agent        ➜ JavaAgent模块，提供Mock测试相关功能
 |-- testable-core         ➜ 基础功能模块，提供Mock相关注解和工具类
 |-- testable-maven-plugin ➜ Maven插件模块，用于简化JavaAgent注入
+|-- tool                  ➜ 项目开发过程中的工具脚本
 |-- demo
 |   |-- java-demo         ➜ Java语言的示例代码
 |   `-- kotlin-demo       ➜ Kotlin语言的示例代码

README_EN.md

@@ -7,13 +7,12 @@ Write a mock method, add an `@MockMethod` annotation, everything is done.
 
 Usage Document: https://alibaba.github.io/testable-mock/#/en-us/
 
-## Loadmap
+## Roadmap
 
 `TestableMock` is still under heavy development, the following version plans may be adjusted during the iteration
 
-- `v0.4` it's the current version, refer to the [issue](https://github.com/alibaba/testable-mock/issues) list for the work in progress
-- `v0.5` implementation mock class inherit mechanism, so that the same mock method can be reused between test classes conveniently
-- `v0.6` narrows the default effective scope of mock methods to the class under test, to avoid interaction of mocking cross classes
+- `v0.6` it's the current version, refer to the [issue](https://github.com/alibaba/testable-mock/issues) list for the work in progress
+- `v0.7` better anti-refactor support of mocking, allow quick mock all method in specified class
 - `v1.0` all functions are stable, a brand-new start
 
 ## Directory Structure
@@ -25,6 +24,7 @@ Usage Document: https://alibaba.github.io/testable-mock/#/en-us/
 |-- testable-agent        ➜ JavaAgent module, provides test mocking related functions
 |-- testable-core         ➜ Basic function module, provides mock related class and annotation
 |-- testable-maven-plugin ➜ Maven plugin module, for simplify JavaAgent injection
+|-- tool                  ➜ Scripts for project maintain
 |-- demo
 |   |-- java-demo         ➜ Java code example
 |   `-- kotlin-demo       ➜ Kotlin code example

demo/java-demo/build.gradle

@@ -12,9 +12,9 @@ repositories {
 }
 
 dependencies {
-    testImplementation('junit:junit:4.13.1')
-    testImplementation('com.alibaba.testable:testable-all:0.4.11')
-    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.4.11')
+    testImplementation('org.junit.jupiter:junit-jupiter:5.6.2')
+    testImplementation('com.alibaba.testable:testable-all:0.6.5')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.5')
 }
 
 tasks.withType(JavaCompile) {
@@ -23,5 +23,5 @@ tasks.withType(JavaCompile) {
 
 test {
     jvmArgs "-javaagent:${classpath.find { it.name.contains("testable-agent") }.absolutePath}"
-    useJUnit()
+    useJUnitPlatform()
 }

demo/java-demo/pom.xml

@@ -11,8 +11,8 @@
     <properties>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
-        <junit.version>4.13.1</junit.version>
-        <testable.version>0.4.11</testable.version>
+        <junit.version>5.6.2</junit.version>
+        <testable.version>0.6.5</testable.version>
     </properties>
 
     <dependencies>
@@ -23,8 +23,8 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
             <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
@@ -32,7 +32,6 @@
 
     <build>
         <plugins>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>

demo/java-demo/src/main/java/com/alibaba/demo/association/CookerService.java

@@ -0,0 +1,33 @@
+package com.alibaba.demo.association;
+
+/**
+ * 目标类，此类中的一些调用将会被Mock掉
+ * Target class, some invocations inside this class will be mocked
+ */
+public class CookerService {
+
+    private static String hireSandwichCooker() {
+        return "Real-Sandwich-Cooker";
+    }
+
+    private static String hireHamburgerCooker() {
+        return "Real-Hamburger-Cooker";
+    }
+
+    private String cookSandwich() {
+        return "Real-Sandwich";
+    }
+
+    private String cookHamburger() {
+        return "Real-Hamburger";
+    }
+
+    public String prepareSandwich() {
+        return hireSandwichCooker() + " & " + cookSandwich();
+    }
+
+    public String prepareHamburger() {
+        return hireHamburgerCooker() + " & " + cookHamburger();
+    }
+
+}

demo/java-demo/src/main/java/com/alibaba/demo/association/SellerService.java

@@ -0,0 +1,18 @@
+package com.alibaba.demo.association;
+
+/**
+ * 被测类，会访问`CookerService`里的方法
+ * Class to be tested, which will access methods in TargetService class
+ */
+public class SellerService {
+
+    private CookerService cookerService = new CookerService();
+
+    public String sellSandwich() {
+        return cookerService.prepareSandwich();
+    }
+
+    public String sellHamburger() {
+        return cookerService.prepareHamburger();
+    }
+}

demo/java-demo/src/main/java/com/alibaba/demo/basic/DemoInherit.java

@@ -1,8 +1,8 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
-import com.alibaba.testable.demo.model.BlackBox;
-import com.alibaba.testable.demo.model.Box;
-import com.alibaba.testable.demo.model.Color;
+import com.alibaba.demo.basic.model.mock.BlackBox;
+import com.alibaba.demo.basic.model.mock.Box;
+import com.alibaba.demo.basic.model.mock.Color;
 
 /**
  * 演示父类变量引用子类对象时的Mock场景

demo/java-demo/src/main/java/com/alibaba/demo/basic/DemoInnerClass.java

@@ -0,0 +1,60 @@
+package com.alibaba.demo.basic;
+
+import java.util.concurrent.*;
+
+/**
+ * 演示对内部类的Mock支持
+ * Demonstrate support for mocking invocation inside a inner class
+ */
+public class DemoInnerClass {
+
+    public static class StaticInner {
+        /**
+         * invocation inside a static inner class
+         */
+        public String demo() {
+            return methodToBeMock();
+        }
+    }
+
+    public class Inner {
+        /**
+         * invocation inside a non-static inner class
+         */
+        public String demo() {
+            return methodToBeMock();
+        }
+    }
+
+    private ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    public String callAnonymousInner() throws ExecutionException, InterruptedException {
+        /**
+         * invocation inside a anonymous inner class
+         */
+        Future<String> future = executorService.submit(new Callable<String>() {
+            @Override
+            public String call() throws Exception {
+                return methodToBeMock();
+            }
+        });
+        return future.get();
+    }
+
+    public String callLambdaInner() throws ExecutionException, InterruptedException {
+        /**
+         * invocation inside a lambda inner class
+         */
+        Future<String> future = executorService.submit(() -> methodToBeMock());
+        return future.get();
+    }
+
+    public String callInnerDemo() {
+        return new Inner().demo();
+    }
+
+    public static String methodToBeMock() {
+        return "RealCall";
+    }
+
+}

demo/java-demo/src/main/java/com/alibaba/demo/basic/DemoMatcher.java

@@ -1,7 +1,7 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
 
-import com.alibaba.testable.demo.model.BlackBox;
+import com.alibaba.demo.basic.model.mock.BlackBox;
 
 import java.util.ArrayList;
 import java.util.HashMap;

demo/java-demo/src/main/java/com/alibaba/demo/basic/DemoMock.java

@@ -1,6 +1,6 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
-import com.alibaba.testable.demo.model.BlackBox;
+import com.alibaba.demo.basic.model.mock.BlackBox;
 
 import java.nio.file.Files;
 import java.nio.file.Paths;

demo/java-demo/src/main/java/com/alibaba/demo/basic/DemoPrivateAccess.java

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
 import java.util.List;
 

demo/java-demo/src/main/java/com/alibaba/demo/basic/DemoTemplate.java

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
 import java.util.*;
 

demo/java-demo/src/main/java/com/alibaba/demo/basic/model/mock/BlackBox.java

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.model;
+package com.alibaba.demo.basic.model.mock;
 
 public class BlackBox extends Box implements Color {
 

demo/java-demo/src/main/java/com/alibaba/demo/basic/model/mock/Box.java

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.model;
+package com.alibaba.demo.basic.model.mock;
 
 abstract public class Box {
 

demo/java-demo/src/main/java/com/alibaba/demo/basic/model/mock/Color.java

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.model;
+package com.alibaba.demo.basic.model.mock;
 
 public interface Color {
 

demo/java-demo/src/main/java/com/alibaba/demo/basic/model/omni/Child.java

@@ -0,0 +1,47 @@
+package com.alibaba.demo.basic.model.omni;
+
+public class Child {
+
+    /**
+     * 我是一个私有的构造方法
+     * This class have only private constructor
+     */
+    private Child() {
+    }
+
+    // ---------- 内部成员字段 ----------
+
+    private GrandChild grandChild;
+
+    private InnerChild subChild;
+
+    /* ---------------------------------------
+    以下Getters/Setters方法仅为便于功能演示而添加
+    并非OmniConstructor或OmniAccessor功能所需
+    --------------------------------------- */
+
+    public GrandChild getGrandChild() {
+        return grandChild;
+    }
+
+    public void setGrandChild(GrandChild grandChild) {
+        this.grandChild = grandChild;
+    }
+
+    public InnerChild getSubChild() {
+        return subChild;
+    }
+
+    public void setSubChild(InnerChild subChild) {
+        this.subChild = subChild;
+    }
+
+    /**
+     * 这是一个私有内部类
+     * An private inner class
+     */
+    private class InnerChild {
+        private String secret;
+    }
+
+}

demo/java-demo/src/main/java/com/alibaba/demo/basic/model/omni/GrandChild.java

@@ -0,0 +1,31 @@
+package com.alibaba.demo.basic.model.omni;
+
+public class GrandChild {
+
+    // ---------- 内部成员字段 ----------
+
+    private int value;
+
+    private String content;
+
+    /* ---------------------------------------
+    以下Getters/Setters方法仅为便于功能演示而添加
+    并非OmniConstructor或OmniAccessor功能所需
+    --------------------------------------- */
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+}

demo/java-demo/src/main/java/com/alibaba/demo/basic/model/omni/Parent.java

@@ -0,0 +1,40 @@
+package com.alibaba.demo.basic.model.omni;
+
+public class Parent {
+
+    /**
+     * 我是一个虽然存在但无法正常使用的构造方法
+     * This class have constructor with exception throw
+     */
+    public Parent() {
+        throw new IllegalArgumentException();
+    }
+
+    // ---------- 内部成员字段 ----------
+
+    private Child child;
+
+    private Child[] children;
+
+    /* ---------------------------------------
+    以下Getters/Setters方法仅为便于功能演示而添加
+    并非OmniConstructor或OmniAccessor功能所需
+    --------------------------------------- */
+
+    public Child getChild() {
+        return child;
+    }
+
+    public void setChild(Child child) {
+        this.child = child;
+    }
+
+    public Child[] getChildren() {
+        return children;
+    }
+
+    public void setChildren(Child[] children) {
+        this.children = children;
+    }
+
+}

demo/java-demo/src/main/java/com/alibaba/demo/one2multi/ASvc.java

@@ -0,0 +1,9 @@
+package com.alibaba.demo.one2multi;
+
+public class ASvc {
+
+    public String demo(String name) {
+        return String.format("a_%s", name);
+    }
+
+}

demo/java-demo/src/main/java/com/alibaba/demo/one2multi/BSvc.java

@@ -0,0 +1,9 @@
+package com.alibaba.demo.one2multi;
+
+public class BSvc {
+
+    public String demo(String name) {
+        return String.format("b_%s", name);
+    }
+
+}

demo/java-demo/src/main/java/com/alibaba/demo/one2multi/CSvc.java

@@ -0,0 +1,9 @@
+package com.alibaba.demo.one2multi;
+
+public class CSvc {
+
+    public String demo(String name) {
+        return String.format("c_%s", name);
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/association/CookerServiceMock.java

@@ -0,0 +1,27 @@
+package com.alibaba.demo.association;
+
+import com.alibaba.testable.core.annotation.MockMethod;
+import com.alibaba.testable.core.model.MockScope;
+
+class CookerServiceMock {
+
+    @MockMethod(targetClass = CookerService.class)
+    public static String hireSandwichCooker() {
+        return "Fake-Sandwich-Cooker";
+    }
+
+    @MockMethod(targetClass = CookerService.class, scope = MockScope.ASSOCIATED)
+    public static String hireHamburgerCooker() {
+        return "Fake-Hamburger-Cooker";
+    }
+
+    @MockMethod(targetClass = CookerService.class)
+    private String cookSandwich() {
+        return "Faked-Sandwich";
+    }
+
+    @MockMethod(targetClass = CookerService.class, scope = MockScope.ASSOCIATED)
+    private String cookHamburger() {
+        return "Faked-Hamburger";
+    }
+}

demo/java-demo/src/test/java/com/alibaba/demo/association/SellerServiceTest.java

@@ -0,0 +1,21 @@
+package com.alibaba.demo.association;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SellerServiceTest {
+
+    private SellerService sellerService = new SellerService();
+
+    @Test
+    void should_sell_sandwich() {
+        assertEquals("Fake-Sandwich-Cooker & Faked-Sandwich", sellerService.sellSandwich());
+    }
+
+    @Test
+    void should_sell_hamburger() {
+        assertEquals("Real-Hamburger-Cooker & Real-Hamburger", sellerService.sellHamburger());
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoInheritTest.java

@@ -0,0 +1,94 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.demo.basic.model.mock.BlackBox;
+import com.alibaba.demo.basic.model.mock.Box;
+import com.alibaba.demo.basic.model.mock.Color;
+import com.alibaba.testable.core.annotation.MockMethod;
+import org.junit.jupiter.api.Test;
+
+import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * 演示父类变量引用子类对象时的Mock场景
+ * Demonstrate scenario of mocking method from sub-type object referred by parent-type variable
+ */
+class DemoInheritTest {
+
+    private DemoInherit demoInherit = new DemoInherit();
+
+    public static class Mock {
+        @MockMethod(targetMethod = "put")
+        private void put_into_box(Box self, String something) {
+            self.put("put_" + something + "_into_box");
+        }
+
+        @MockMethod(targetMethod = "put")
+        private void put_into_blackbox(BlackBox self, String something) {
+            self.put("put_" + something + "_into_blackbox");
+        }
+
+        @MockMethod(targetMethod = "get")
+        private String get_from_box(Box self) {
+            return "get_from_box";
+        }
+
+        @MockMethod(targetMethod = "get")
+        private String get_from_blackbox(BlackBox self) {
+            return "get_from_blackbox";
+        }
+
+        @MockMethod(targetMethod = "getColor")
+        private String get_color_from_color(Color self) {
+            return "color_from_color";
+        }
+
+        @MockMethod(targetMethod = "getColor")
+        private String get_color_from_blackbox(BlackBox self) {
+        return "color_from_blackbox";
+    }
+    }
+
+    @Test
+    void should_mock_call_sub_object_method_by_parent_object() {
+        BlackBox box = (BlackBox)demoInherit.putIntoBox();
+        verify("put_into_box").withTimes(1);
+        assertEquals("put_data_into_box", box.get());
+    }
+
+    @Test
+    void should_mock_call_sub_object_method_by_sub_object() {
+        BlackBox box = demoInherit.putIntoBlackBox();
+        verify("put_into_blackbox").withTimes(1);
+        assertEquals("put_data_into_blackbox", box.get());
+    }
+
+    @Test
+    void should_mock_call_parent_object_method_by_parent_object() {
+        String content = demoInherit.getFromBox();
+        verify("get_from_box").withTimes(1);
+        assertEquals("get_from_box", content);
+    }
+
+    @Test
+    void should_mock_call_parent_object_method_by_sub_object() {
+        String content = demoInherit.getFromBlackBox();
+        verify("get_from_blackbox").withTimes(1);
+        assertEquals("get_from_blackbox", content);
+    }
+
+    @Test
+    void should_mock_call_interface_method_by_interface_object() {
+        String color = demoInherit.getColorViaColor();
+        verify("get_color_from_color").withTimes(1);
+        assertEquals("color_from_color", color);
+    }
+
+    @Test
+    void should_mock_call_interface_method_by_sub_class_object() {
+        String color = demoInherit.getColorViaBox();
+        verify("get_color_from_blackbox").withTimes(1);
+        assertEquals("color_from_blackbox", color);
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoInnerClassTest.java

@@ -0,0 +1,29 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.testable.core.annotation.MockMethod;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * 演示对内部类的Mock支持
+ * Demonstrate support for mocking invocation inside a inner class
+ */
+class DemoInnerClassTest {
+
+    public static class Mock {
+        @MockMethod(targetClass = DemoInnerClass.class)
+        String methodToBeMock() {
+            return "MockedCall";
+        }
+    }
+
+    @Test
+    void should_mock_invoke_inside_inner_class() throws Exception {
+        DemoInnerClass demo = new DemoInnerClass();
+        assertEquals("MockedCall", demo.callInnerDemo());
+        assertEquals("MockedCall", demo.callAnonymousInner());
+        assertEquals("MockedCall", demo.callLambdaInner());
+        assertEquals("MockedCall", new DemoInnerClass.StaticInner().demo());
+    }
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoMatcherTest.java

@@ -1,34 +1,35 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
+import com.alibaba.demo.basic.model.mock.BlackBox;
 import com.alibaba.testable.core.annotation.MockMethod;
 import com.alibaba.testable.core.error.VerifyFailedError;
-import com.alibaba.testable.demo.model.BlackBox;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static com.alibaba.testable.core.matcher.InvokeMatcher.*;
 import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.fail;
 
 /**
  * 演示Mock方法调用校验器
  * Demonstrate mock method invocation verifier
  */
-public class DemoMatcherTest {
+class DemoMatcherTest {
 
     private DemoMatcher demoMatcher = new DemoMatcher();
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private void methodWithoutArgument(DemoMatcher self) {}
+    public static class Mock {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithoutArgument(DemoMatcher self) {}
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private void methodWithArguments(DemoMatcher self, Object a1, Object a2) {}
-
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private void methodWithArrayArgument(DemoMatcher self, Object[] a) {}
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithArguments(DemoMatcher self, Object a1, Object a2) {}
 
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithArrayArgument(DemoMatcher self, Object[] a) {}
+    }
 
     @Test
-    public void should_match_no_argument() {
+    void should_match_no_argument() {
         demoMatcher.callMethodWithoutArgument();
         verify("methodWithoutArgument").withTimes(1);
         demoMatcher.callMethodWithoutArgument();
@@ -36,7 +37,7 @@ public class DemoMatcherTest {
     }
 
     @Test
-    public void should_match_number_arguments() {
+    void should_match_number_arguments() {
         demoMatcher.callMethodWithNumberArguments();
         verify("methodWithArguments").without(anyString(), 2);
         verify("methodWithArguments").withInOrder(anyInt(), 2);
@@ -49,7 +50,7 @@ public class DemoMatcherTest {
     }
 
     @Test
-    public void should_match_string_arguments() {
+    void should_match_string_arguments() {
         demoMatcher.callMethodWithStringArgument();
         verify("methodWithArguments").with(startsWith("he"), endsWith("ld"));
         verify("methodWithArguments").with(contains("stab"), matches("m.[cd]k"));
@@ -57,7 +58,7 @@ public class DemoMatcherTest {
     }
 
     @Test
-    public void should_match_object_arguments() {
+    void should_match_object_arguments() {
         demoMatcher.callMethodWithObjectArgument();
         verify("methodWithArguments").withInOrder(any(BlackBox.class), any(BlackBox.class));
         verify("methodWithArguments").withInOrder(nullable(BlackBox.class), nullable(BlackBox.class));
@@ -65,7 +66,7 @@ public class DemoMatcherTest {
     }
 
     @Test
-    public void should_match_with_times() {
+    void should_match_with_times() {
         demoMatcher.callMethodWithNumberArguments();
         verify("methodWithArguments").with(anyNumber(), any()).times(3);
 

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoMockTest.java

@@ -0,0 +1,121 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.demo.basic.model.mock.BlackBox;
+import com.alibaba.testable.core.annotation.MockConstructor;
+import com.alibaba.testable.core.annotation.MockMethod;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.Executors;
+
+import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
+import static com.alibaba.testable.core.tool.TestableTool.MOCK_CONTEXT;
+import static com.alibaba.testable.core.tool.TestableTool.SOURCE_METHOD;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * 演示基本的Mock功能
+ * Demonstrate basic mock functionality
+ */
+class DemoMockTest {
+
+    private DemoMock demoMock = new DemoMock();
+
+    public static class Mock {
+        @MockConstructor
+        private BlackBox createBlackBox(String text) {
+            return new BlackBox("mock_" + text);
+        }
+
+        @MockMethod(targetClass = DemoMock.class)
+        private String innerFunc(String text) {
+            return "mock_" + text;
+        }
+
+        @MockMethod(targetClass = DemoMock.class)
+        private String staticFunc() {
+            return "_MOCK_TAIL";
+        }
+
+        @MockMethod(targetClass = String.class)
+        private String trim() {
+            return "trim_string";
+        }
+
+        @MockMethod(targetClass = String.class, targetMethod = "substring")
+        private String sub(int i, int j) {
+            return "sub_string";
+        }
+
+        @MockMethod(targetClass = String.class)
+        private boolean startsWith(String s) {
+            return false;
+        }
+
+        @MockMethod(targetClass = BlackBox.class)
+        private BlackBox secretBox() {
+            return new BlackBox("not_secret_box");
+        }
+
+        @MockMethod(targetClass = DemoMock.class)
+        private String callFromDifferentMethod() {
+            if ("special_case".equals(MOCK_CONTEXT.get("case"))) {
+                return "mock_special";
+            }
+            switch (SOURCE_METHOD) {
+                case "callerOne":
+                    return "mock_one";
+                default:
+                    return "mock_others";
+            }
+        }
+    }
+
+    @Test
+    void should_mock_new_object() {
+        assertEquals("mock_something", demoMock.newFunc());
+        verify("createBlackBox").with("something");
+    }
+
+    @Test
+    void should_mock_member_method() throws Exception {
+        assertEquals("{ \"res\": \"mock_hello_MOCK_TAIL\"}", demoMock.outerFunc("hello"));
+        verify("innerFunc").with("hello");
+        verify("staticFunc").with();
+    }
+
+    @Test
+    void should_mock_common_method() {
+        assertEquals("trim_string__sub_string__false", demoMock.commonFunc());
+        verify("trim").withTimes(1);
+        verify("sub").withTimes(1);
+        verify("startsWith").withTimes(1);
+    }
+
+    @Test
+    void should_mock_static_method() {
+        Assertions.assertEquals("not_secret_box", demoMock.getBox().get());
+        verify("secretBox").withTimes(1);
+    }
+
+    @Test
+    void should_get_source_method_name() throws Exception {
+        // synchronous
+        assertEquals("mock_one_mock_others", demoMock.callerOne() + "_" + demoMock.callerTwo());
+        // asynchronous
+        assertEquals("mock_one_mock_others",
+            Executors.newSingleThreadExecutor().submit(() -> demoMock.callerOne() + "_" + demoMock.callerTwo()).get());
+        verify("callFromDifferentMethod").withTimes(4);
+    }
+
+    @Test
+    void should_set_mock_context() throws Exception {
+        MOCK_CONTEXT.put("case", "special_case");
+        // synchronous
+        assertEquals("mock_special", demoMock.callerOne());
+        // asynchronous
+        assertEquals("mock_special", Executors.newSingleThreadExecutor().submit(() -> demoMock.callerOne()).get());
+        verify("callFromDifferentMethod").withTimes(2);
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoOmniMethodsTest.java

@@ -0,0 +1,91 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.demo.basic.model.omni.Child;
+import com.alibaba.demo.basic.model.omni.Parent;
+import com.alibaba.testable.core.tool.OmniAccessor;
+import com.alibaba.testable.core.tool.OmniConstructor;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+/**
+ * 演示快速创建任意对象和使用路径访问成员
+ * Demonstrate quick object construction and access members by path
+ */
+class DemoOmniMethodsTest {
+
+    @Test
+    void should_construct_any_class() {
+        Parent parent = OmniConstructor.newInstance(Parent.class);
+
+        // 任意深度的子孙成员对象都不为空
+        assertNotNull(parent.getChild().getGrandChild().getContent());
+
+        // 所有基础类型初始化为默认数值
+        assertEquals(0, parent.getChild().getGrandChild().getValue());
+        assertEquals("", parent.getChild().getGrandChild().getContent());
+
+        // 所有数组类型初始化为空数组
+        assertEquals(0, parent.getChildren().length);
+    }
+
+    @Test
+    void should_get_any_member() {
+        Parent parent = OmniConstructor.newInstance(Parent.class);
+        parent.setChildren(OmniConstructor.newArray(Child.class, 3));
+        parent.getChild().getGrandChild().setContent("from child");
+        parent.getChildren()[0].getGrandChild().setContent("from 1st children");
+        parent.getChildren()[1].getGrandChild().setContent("from 2nd children");
+        parent.getChildren()[2].getGrandChild().setContent("from 3rd children");
+
+        // 使用成员名称快速读取成员对象
+        List<String> contents = OmniAccessor.get(parent, "content");
+        assertEquals(4, contents.size());
+        assertEquals("from child", contents.get(0));
+        assertEquals("from 1st children", contents.get(1));
+        assertEquals("from 2nd children", contents.get(2));
+        assertEquals("from 3rd children", contents.get(3));
+
+        // 使用成员类型快速读取成员对象
+        contents = OmniAccessor.get(parent, "{Child}/{GrandChild}/content");
+        assertEquals(1, contents.size());
+        assertEquals("from child", contents.get(0));
+
+        // 使用带下标的路径读取成员对象
+        assertEquals("from 2nd children", OmniAccessor.getFirst(parent, "children[1]/{GrandChild}/content"));
+        assertEquals("from 3rd children", OmniAccessor.getFirst(parent, "{Child[]}[2]/{GrandChild}/content"));
+
+        // 使用模糊路径快速读取成员对象
+        assertEquals("from 1st children", OmniAccessor.getFirst(parent, "{C*[]}[0]/*/con*t"));
+    }
+
+    @Test
+    void should_set_any_member() {
+        Parent parent = OmniConstructor.newInstance(Parent.class);
+        parent.setChildren(OmniConstructor.newArray(Child.class, 3));
+
+        // 使用指定路径快速给成员对象赋值
+        OmniAccessor.set(parent, "child/grandChild/content", "demo child");
+        assertEquals("demo child", parent.getChild().getGrandChild().getContent());
+
+        // 使用带下标的路径给成员对象赋值
+        OmniAccessor.set(parent, "children[1]/grandChild/content", "demo children[1]");
+        assertEquals("demo children[1]", parent.getChildren()[1].getGrandChild().getContent());
+
+        // 使用模糊路径批量给成员对象赋值
+        OmniAccessor.set(parent, "child*/*/content", "demo in batch");
+        assertEquals("demo in batch", parent.getChild().getGrandChild().getContent());
+        assertEquals("demo in batch", parent.getChildren()[0].getGrandChild().getContent());
+        assertEquals("demo in batch", parent.getChildren()[1].getGrandChild().getContent());
+        assertEquals("demo in batch", parent.getChildren()[2].getGrandChild().getContent());
+
+        // 读写私有内部类类型的成员（使用类型名引用内部类时，无需带外部类名）
+        assertEquals("", OmniAccessor.getFirst(parent, "subChild/secret"));
+        OmniAccessor.set(parent, "{InnerChild}/secret", "inner-class secret");
+        assertEquals("inner-class secret", OmniAccessor.getFirst(parent, "subChild/secret"));
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoPrivateAccessorTest.java

@@ -0,0 +1,58 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.testable.core.tool.PrivateAccessor;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * 演示使用`PrivateAccessor`工具类访问私有成员
+ * Demonstrate access private member via `PrivateAccessor` class
+ */
+class DemoPrivateAccessorTest {
+
+    private DemoPrivateAccess demoPrivateAccess = new DemoPrivateAccess();
+
+    @Test
+    void should_access_private_method() {
+        List<String> list = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }};
+        assertEquals("member", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc"));
+        assertEquals("abc + hello + 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFuncWithArgs", list, "hello", 1));
+    }
+
+    @Test
+    void should_access_private_field() {
+        PrivateAccessor.set(demoPrivateAccess, "count", 3);
+        assertEquals(Integer.valueOf(3), PrivateAccessor.get(demoPrivateAccess, "count"));
+    }
+
+    @Test
+    void should_access_private_static_method() {
+        assertEquals("static", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFunc"));
+        assertEquals("hello + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", "hello", 1));
+    }
+
+    @Test
+    void should_access_private_static_field() {
+        PrivateAccessor.setStatic(DemoPrivateAccess.class, "staticCount", 3);
+        assertEquals(Integer.valueOf(3), PrivateAccessor.getStatic(DemoPrivateAccess.class, "staticCount"));
+    }
+
+    @Test
+    void should_update_final_field() {
+        PrivateAccessor.set(demoPrivateAccess, "pi", 3.14);
+        assertEquals(Double.valueOf(3.14), PrivateAccessor.get(demoPrivateAccess, "pi"));
+    }
+
+    @Test
+    void should_use_null_parameter() {
+        PrivateAccessor.set(demoPrivateAccess, "pi", null);
+        assertNull(PrivateAccessor.get(demoPrivateAccess, "pi"));
+        assertEquals("null + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", null, 1));
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoPrivateProcessorTest.java

@@ -0,0 +1,59 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.testable.processor.annotation.EnablePrivateAccess;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * 演示使用`@EnablePrivateAccess`注解访问私有成员
+ * Demonstrate access private member via `@EnablePrivateAccess` annotation
+ */
+@EnablePrivateAccess(srcClass = DemoPrivateAccess.class)
+class DemoPrivateProcessorTest {
+
+    private DemoPrivateAccess demoPrivateAccess = new DemoPrivateAccess();
+
+    @Test
+    void should_access_private_method() {
+        List<String> list = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }};
+        assertEquals("member", demoPrivateAccess.privateFunc());
+        assertEquals("abc + hello + 1", demoPrivateAccess.privateFuncWithArgs(list, "hello", 1));
+    }
+
+    @Test
+    void should_access_private_field() {
+        demoPrivateAccess.count = 2;
+        assertEquals(Integer.valueOf(2), demoPrivateAccess.count);
+    }
+
+    @Test
+    void should_access_private_static_method() {
+        assertEquals("static", DemoPrivateAccess.privateStaticFunc());
+        assertEquals("hello + 1", DemoPrivateAccess.privateStaticFuncWithArgs("hello", 1));
+    }
+
+    @Test
+    void should_access_private_static_field() {
+        DemoPrivateAccess.staticCount = 2;
+        assertEquals(Integer.valueOf(2), DemoPrivateAccess.staticCount);
+    }
+
+    @Test
+    void should_update_final_field() {
+        demoPrivateAccess.pi = 4.13;
+        assertEquals(Double.valueOf(4.13), demoPrivateAccess.pi);
+    }
+
+    @Test
+    void should_use_null_parameter() {
+        demoPrivateAccess.pi = null;
+        assertNull(demoPrivateAccess.pi);
+        assertEquals("null + 1", DemoPrivateAccess.privateStaticFuncWithArgs(null, 1));
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoTemplateTest.java

@@ -0,0 +1,95 @@
+package com.alibaba.demo.basic;
+
+import com.alibaba.testable.core.annotation.MockConstructor;
+import com.alibaba.testable.core.annotation.MockMethod;
+import com.alibaba.demo.basic.DemoTemplate;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * 演示模板方法的Mock场景
+ * Demonstrate scenario of mocking template method
+ */
+class DemoTemplateTest {
+
+    private DemoTemplate demoTemplate = new DemoTemplate();
+
+    public static class Mock {
+        /* 第一种写法：使用泛型定义 */
+        /* First solution: use generics type */
+
+        @MockMethod
+        private <T> List<T> getList(DemoTemplate self, T value) {
+            return new ArrayList<T>() {{ add((T)(value.toString() + "_mock_list")); }};
+        }
+
+        @MockMethod
+        private <K, V> Map<K, V> getMap(DemoTemplate self, K key, V value) {
+            return new HashMap<K, V>() {{ put(key, (V)(value.toString() + "_mock_map")); }};
+        }
+
+        @MockConstructor
+        private <T> HashSet<T> newHashSet() {
+            HashSet<T> set = new HashSet<>();
+            set.add((T)"insert_mock");
+            return set;
+        }
+
+        @MockMethod
+        private <E> boolean add(Set s, E e) {
+            s.add(e.toString() + "_mocked");
+            return true;
+        }
+
+        /* 第二种写法：使用Object类型 */
+        /* Second solution: use object type */
+
+        //@MockMethod
+        //private List<Object> getList(DemoTemplate self, Object value) {
+        //    return new ArrayList<Object>() {{ add(value.toString() + "_mock_list"); }};
+        //}
+        //
+        //@MockMethod
+        //private Map<Object, Object> getMap(DemoTemplate self, Object key, Object value) {
+        //    return new HashMap<Object, Object>() {{ put(key, value.toString() + "_mock_map"); }};
+        //}
+        //
+        //@MockConstructor
+        //private HashSet newHashSet() {
+        //    HashSet<Object> set = new HashSet<>();
+        //    set.add("insert_mock");
+        //    return set;
+        //}
+        //
+        //@MockMethod
+        //private boolean add(Set s, Object e) {
+        //    s.add(e.toString() + "_mocked");
+        //    return true;
+        //}
+    }
+
+    @Test
+    void should_mock_single_template_method() {
+        String res = demoTemplate.singleTemplateMethod();
+        assertEquals("demo_mock_list", res);
+    }
+
+    @Test
+    void should_mock_double_template_method() {
+        String res = demoTemplate.doubleTemplateMethod();
+        assertEquals("testable_mock_map", res);
+    }
+
+    @Test
+    void should_mock_new_template_method() {
+        Set<?> res = demoTemplate.newTemplateMethod();
+        assertEquals(2, res.size());
+        Iterator<?> iterator = res.stream().iterator();
+        assertEquals("insert_mock", iterator.next());
+        assertEquals("world_mocked", iterator.next());
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/one2multi/ASvcMock.java

@@ -0,0 +1,12 @@
+package com.alibaba.demo.one2multi;
+
+import com.alibaba.testable.core.annotation.MockMethod;
+
+public class ASvcMock {
+
+    @MockMethod(targetClass = String.class, targetMethod = "format")
+    public String a_format(String format, Object... args) {
+        return "a_mock";
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/one2multi/BSvcMock.java

@@ -0,0 +1,12 @@
+package com.alibaba.demo.one2multi;
+
+import com.alibaba.testable.core.annotation.MockMethod;
+
+public class BSvcMock {
+
+    @MockMethod(targetClass = String.class, targetMethod = "format")
+    public String b_format(String format, Object... args) {
+        return "b_mock";
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/one2multi/CSvcMock.java

@@ -0,0 +1,12 @@
+package com.alibaba.demo.one2multi;
+
+import com.alibaba.testable.core.annotation.MockMethod;
+
+public class CSvcMock {
+
+    @MockMethod(targetClass = String.class, targetMethod = "format")
+    public String c_format(String format, Object... args) {
+        return "c_mock";
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/demo/one2multi/OneToMultiSvcTest.java

@@ -0,0 +1,27 @@
+package com.alibaba.demo.one2multi;
+
+import com.alibaba.testable.core.annotation.MockWith;
+import org.junit.jupiter.api.Test;
+
+
+import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@MockWith
+public class OneToMultiSvcTest {
+
+    private ASvc aSvc = new ASvc();
+    private BSvc bSvc = new BSvc();
+    private CSvc cSvc = new CSvc();
+
+    @Test
+    public void should_test_multi_class_together() {
+        assertEquals("a_mock", aSvc.demo("test"));
+        assertEquals("b_mock", bSvc.demo("test"));
+        assertEquals("c_mock", cSvc.demo("test"));
+        verify("a_format").withTimes(1);
+        verify("b_format").withTimes(1);
+        verify("c_format").withTimes(1);
+    }
+
+}

demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoInheritTest.java

@@ -1,93 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.annotation.MockMethod;
-import com.alibaba.testable.demo.model.BlackBox;
-import com.alibaba.testable.demo.model.Box;
-import com.alibaba.testable.demo.model.Color;
-import org.junit.Test;
-
-import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
-import static org.junit.Assert.assertEquals;
-
-/**
- * 演示父类变量引用子类对象时的Mock场景
- * Demonstrate scenario of mocking method from sub-type object referred by parent-type variable
- */
-public class DemoInheritTest {
-
-    private DemoInherit demoInherit = new DemoInherit();
-
-    @MockMethod(targetMethod = "put")
-    private void put_into_box(Box self, String something) {
-        self.put("put_" + something + "_into_box");
-    }
-
-    @MockMethod(targetMethod = "put")
-    private void put_into_blackbox(BlackBox self, String something) {
-        self.put("put_" + something + "_into_blackbox");
-    }
-
-    @MockMethod(targetMethod = "get")
-    private String get_from_box(Box self) {
-        return "get_from_box";
-    }
-
-    @MockMethod(targetMethod = "get")
-    private String get_from_blackbox(BlackBox self) {
-        return "get_from_blackbox";
-    }
-
-    @MockMethod(targetMethod = "getColor")
-    private String get_color_from_color(Color self) {
-        return "color_from_color";
-    }
-
-    @MockMethod(targetMethod = "getColor")
-    private String get_color_from_blackbox(BlackBox self) {
-        return "color_from_blackbox";
-    }
-
-
-    @Test
-    public void should_able_to_mock_call_sub_object_method_by_parent_object() {
-        BlackBox box = (BlackBox)demoInherit.putIntoBox();
-        verify("put_into_box").withTimes(1);
-        assertEquals("put_data_into_box", box.get());
-    }
-
-    @Test
-    public void should_able_to_mock_call_sub_object_method_by_sub_object() {
-        BlackBox box = demoInherit.putIntoBlackBox();
-        verify("put_into_blackbox").withTimes(1);
-        assertEquals("put_data_into_blackbox", box.get());
-    }
-
-    @Test
-    public void should_able_to_mock_call_parent_object_method_by_parent_object() {
-        String content = demoInherit.getFromBox();
-        verify("get_from_box").withTimes(1);
-        assertEquals("get_from_box", content);
-    }
-
-    @Test
-    public void should_able_to_mock_call_parent_object_method_by_sub_object() {
-        String content = demoInherit.getFromBlackBox();
-        verify("get_from_blackbox").withTimes(1);
-        assertEquals("get_from_blackbox", content);
-    }
-
-    @Test
-    public void should_able_to_mock_call_interface_method_by_interface_object() {
-        String color = demoInherit.getColorViaColor();
-        verify("get_color_from_color").withTimes(1);
-        assertEquals("color_from_color", color);
-    }
-
-    @Test
-    public void should_able_to_mock_call_interface_method_by_sub_class_object() {
-        String color = demoInherit.getColorViaBox();
-        verify("get_color_from_blackbox").withTimes(1);
-        assertEquals("color_from_blackbox", color);
-    }
-
-}

demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMockTest.java

@@ -1,118 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.annotation.MockConstructor;
-import com.alibaba.testable.core.annotation.MockMethod;
-import com.alibaba.testable.demo.model.BlackBox;
-import org.junit.Test;
-
-import java.util.concurrent.Executors;
-
-import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
-import static com.alibaba.testable.core.tool.TestableTool.MOCK_CONTEXT;
-import static com.alibaba.testable.core.tool.TestableTool.SOURCE_METHOD;
-import static org.junit.Assert.assertEquals;
-
-/**
- * 演示基本的Mock功能
- * Demonstrate basic mock functionality
- */
-public class DemoMockTest {
-
-    private DemoMock demoMock = new DemoMock();
-
-    @MockConstructor
-    private BlackBox createBlackBox(String text) {
-        return new BlackBox("mock_" + text);
-    }
-
-    @MockMethod(targetClass = DemoMock.class)
-    private String innerFunc(String text) {
-        return "mock_" + text;
-    }
-
-    @MockMethod(targetClass = DemoMock.class)
-    private String staticFunc() {
-        return "_MOCK_TAIL";
-    }
-
-    @MockMethod(targetClass = String.class)
-    private String trim() {
-        return "trim_string";
-    }
-
-    @MockMethod(targetClass = String.class, targetMethod = "substring")
-    private String sub(int i, int j) {
-        return "sub_string";
-    }
-
-    @MockMethod(targetClass = String.class)
-    private boolean startsWith(String s) {
-        return false;
-    }
-
-    @MockMethod(targetClass = BlackBox.class)
-    private BlackBox secretBox() {
-        return new BlackBox("not_secret_box");
-    }
-
-    @MockMethod(targetClass = DemoMock.class)
-    private String callFromDifferentMethod() {
-        if ("special_case".equals(MOCK_CONTEXT.get("case"))) {
-            return "mock_special";
-        }
-        switch (SOURCE_METHOD) {
-            case "callerOne": return "mock_one";
-            default: return "mock_others";
-        }
-    }
-
-
-    @Test
-    public void should_able_to_mock_new_object() {
-        assertEquals("mock_something", demoMock.newFunc());
-        verify("createBlackBox").with("something");
-    }
-
-    @Test
-    public void should_able_to_mock_member_method() throws Exception {
-        assertEquals("{ \"res\": \"mock_hello_MOCK_TAIL\"}", demoMock.outerFunc("hello"));
-        verify("innerFunc").with("hello");
-        verify("staticFunc").with();
-    }
-
-    @Test
-    public void should_able_to_mock_common_method() {
-        assertEquals("trim_string__sub_string__false", demoMock.commonFunc());
-        verify("trim").withTimes(1);
-        verify("sub").withTimes(1);
-        verify("startsWith").withTimes(1);
-    }
-
-    @Test
-    public void should_able_to_mock_static_method() {
-        assertEquals("not_secret_box", demoMock.getBox().get());
-        verify("secretBox").withTimes(1);
-    }
-
-    @Test
-    public void should_able_to_get_source_method_name() throws Exception {
-        // synchronous
-        assertEquals("mock_one_mock_others", demoMock.callerOne() + "_" + demoMock.callerTwo());
-        // asynchronous
-        assertEquals("mock_one_mock_others",
-            Executors.newSingleThreadExecutor().submit(() -> demoMock.callerOne() + "_" + demoMock.callerTwo()).get());
-        verify("callFromDifferentMethod").withTimes(4);
-    }
-
-    @Test
-    public void should_able_to_get_test_case_name() throws Exception {
-        MOCK_CONTEXT.put("case", "special_case");
-        // synchronous
-        assertEquals("mock_special", demoMock.callerOne());
-        // asynchronous
-        assertEquals("mock_special", Executors.newSingleThreadExecutor().submit(() -> demoMock.callerOne()).get());
-        verify("callFromDifferentMethod").withTimes(2);
-        MOCK_CONTEXT.clear();
-    }
-
-}

demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoPrivateAccessTest.java

@@ -1,77 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.accessor.PrivateAccessor;
-import com.alibaba.testable.processor.annotation.EnablePrivateAccess;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-
-/**
- * 演示私有成员访问功能
- * Demonstrate private member access functionality
- */
-@EnablePrivateAccess
-public class DemoPrivateAccessTest {
-
-    private DemoPrivateAccess demoPrivateAccess = new DemoPrivateAccess();
-
-    @Test
-    public void should_able_to_access_private_method() {
-        List<String> list = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }};
-        assertEquals("member", demoPrivateAccess.privateFunc());
-        assertEquals("member", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc"));
-        assertEquals("abc + hello + 1", demoPrivateAccess.privateFuncWithArgs(list, "hello", 1));
-        assertEquals("abc + hello + 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFuncWithArgs", list, "hello", 1));
-    }
-
-    @Test
-    public void should_able_to_access_private_field() {
-        demoPrivateAccess.count = 2;
-        assertEquals(Integer.valueOf(2), demoPrivateAccess.count);
-
-        PrivateAccessor.set(demoPrivateAccess, "count", 3);
-        assertEquals(Integer.valueOf(3), PrivateAccessor.get(demoPrivateAccess, "count"));
-    }
-
-    @Test
-    public void should_able_to_access_private_static_method() {
-        assertEquals("static", DemoPrivateAccess.privateStaticFunc());
-        assertEquals("static", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFunc"));
-        assertEquals("hello + 1", DemoPrivateAccess.privateStaticFuncWithArgs("hello", 1));
-        assertEquals("hello + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", "hello", 1));
-    }
-
-    @Test
-    public void should_able_to_access_private_static_field() {
-        DemoPrivateAccess.staticCount = 2;
-        assertEquals(Integer.valueOf(2), DemoPrivateAccess.staticCount);
-
-        PrivateAccessor.setStatic(DemoPrivateAccess.class, "staticCount", 3);
-        assertEquals(Integer.valueOf(3), PrivateAccessor.getStatic(DemoPrivateAccess.class, "staticCount"));
-    }
-
-    @Test
-    public void should_able_to_update_final_field() {
-        demoPrivateAccess.pi = 4.13;
-        assertEquals(Double.valueOf(4.13), demoPrivateAccess.pi);
-
-        PrivateAccessor.set(demoPrivateAccess, "pi", 3.14);
-        assertEquals(Double.valueOf(3.14), PrivateAccessor.get(demoPrivateAccess, "pi"));
-    }
-
-    @Test
-    public void should_able_to_use_null_parameter() {
-        demoPrivateAccess.pi = null;
-        assertNull(demoPrivateAccess.pi);
-        assertEquals("null + 1", DemoPrivateAccess.privateStaticFuncWithArgs(null, 1));
-
-        PrivateAccessor.set(demoPrivateAccess, "pi", null);
-        assertNull(PrivateAccessor.get(demoPrivateAccess, "pi"));
-        assertEquals("null + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", null, 1));
-    }
-
-}

demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoTemplateTest.java

@@ -1,93 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.annotation.MockConstructor;
-import com.alibaba.testable.core.annotation.MockMethod;
-import org.junit.Test;
-
-import java.util.*;
-
-import static org.junit.Assert.assertEquals;
-
-/**
- * 演示模板方法的Mock场景
- * Demonstrate scenario of mocking template method
- */
-public class DemoTemplateTest {
-
-    private DemoTemplate demoTemplate = new DemoTemplate();
-
-    /* 第一种写法：使用泛型定义 */
-    /* First solution: use generics type */
-
-    @MockMethod
-    private static <T> List<T> getList(DemoTemplate self, T value) {
-        return new ArrayList<T>() {{ add((T)(value.toString() + "_mock_list")); }};
-    }
-
-    @MockMethod
-    private static <K, V> Map<K, V> getMap(DemoTemplate self, K key, V value) {
-        return new HashMap<K, V>() {{ put(key, (V)(value.toString() + "_mock_map")); }};
-    }
-
-    @MockConstructor
-    private <T> HashSet<T> newHashSet() {
-        HashSet<T> set = new HashSet<>();
-        set.add((T)"insert_mock");
-        return set;
-    }
-
-    @MockMethod
-    private <E> boolean add(Set s, E e) {
-        s.add(e.toString() + "_mocked");
-        return true;
-    }
-
-    /* 第二种写法：使用Object类型 */
-    /* Second solution: use object type */
-
-    //@MockMethod
-    //private static List<Object> getList(DemoTemplate self, Object value) {
-    //    return new ArrayList<Object>() {{ add(value.toString() + "_mock_list"); }};
-    //}
-    //
-    //@MockMethod
-    //private static Map<Object, Object> getMap(DemoTemplate self, Object key, Object value) {
-    //    return new HashMap<Object, Object>() {{ put(key, value.toString() + "_mock_map"); }};
-    //}
-    //
-    //@MockConstructor
-    //private HashSet newHashSet() {
-    //    HashSet<Object> set = new HashSet<>();
-    //    set.add("insert_mock");
-    //    return set;
-    //}
-    //
-    //@MockMethod
-    //private boolean add(Set s, Object e) {
-    //    s.add(e.toString() + "_mocked");
-    //    return true;
-    //}
-
-
-    @Test
-    public void should_able_to_mock_single_template_method() {
-        String res = demoTemplate.singleTemplateMethod();
-        assertEquals("demo_mock_list", res);
-    }
-
-    @Test
-    public void should_able_to_mock_double_template_method() {
-        String res = demoTemplate.doubleTemplateMethod();
-        assertEquals("testable_mock_map", res);
-    }
-
-    @Test
-    public void should_able_to_mock_new_template_method() {
-        Set<?> res = demoTemplate.newTemplateMethod();
-        assertEquals(2, res.size());
-        Iterator<?> iterator = res.stream().iterator();
-        assertEquals("insert_mock", iterator.next());
-        assertEquals("world_mocked", iterator.next());
-    }
-
-}

demo/java-demo/src/test/resources/testable.properties

@@ -0,0 +1 @@
+omni.constructor.enhance.enable = true

demo/kotlin-demo/build.gradle.kts

@@ -16,8 +16,8 @@ dependencies {
     implementation("org.jetbrains.kotlin:kotlin-reflect")
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
     testImplementation("org.junit.jupiter:junit-jupiter:5.6.2")
-    testImplementation("com.alibaba.testable:testable-all:0.4.11")
-    testAnnotationProcessor("com.alibaba.testable:testable-processor:0.4.11")
+    testImplementation("com.alibaba.testable:testable-all:0.6.5")
+    testAnnotationProcessor("com.alibaba.testable:testable-processor:0.6.5")
 }
 
 tasks.withType<KotlinCompile> {

demo/kotlin-demo/pom.xml

@@ -14,7 +14,7 @@
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
         <junit.version>5.6.2</junit.version>
-        <testable.version>0.4.11</testable.version>
+        <testable.version>0.6.5</testable.version>
     </properties>
 
     <dependencies>

demo/kotlin-demo/settings.gradle.kts

@@ -1 +0,0 @@
-rootProject.name = "demo"

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/association/CookerService.kt

@@ -0,0 +1,34 @@
+package com.alibaba.demo.association
+
+/**
+ * 目标类，此类中的一些调用将会被Mock掉
+ * Target class, some invocations inside this class will be mocked
+ */
+class CookerService {
+
+    private fun cookSandwich(): String {
+        return "Real-Sandwich"
+    }
+
+    private fun cookHamburger(): String {
+        return "Real-Hamburger"
+    }
+
+    fun prepareSandwich(): String {
+        return hireSandwichCooker() + " & " + cookSandwich()
+    }
+
+    fun prepareHamburger(): String {
+        return hireHamburgerCooker() + " & " + cookHamburger()
+    }
+
+    companion object {
+        private fun hireSandwichCooker(): String {
+            return "Real-Sandwich-Cooker"
+        }
+
+        private fun hireHamburgerCooker(): String {
+            return "Real-Hamburger-Cooker"
+        }
+    }
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/association/SellerService.kt

@@ -0,0 +1,18 @@
+package com.alibaba.demo.association
+
+/**
+ * 被测类，会访问`CookerService`里的方法
+ * Class to be tested, which will access methods in TargetService class
+ */
+class SellerService {
+
+    private val cookerService = CookerService()
+
+    fun sellSandwich(): String {
+        return cookerService.prepareSandwich()
+    }
+
+    fun sellHamburger(): String {
+        return cookerService.prepareHamburger()
+    }
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/DemoInherit.kt

@@ -1,8 +1,8 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
-import com.alibaba.testable.demo.model.BlackBox
-import com.alibaba.testable.demo.model.Box
-import com.alibaba.testable.demo.model.Color
+import com.alibaba.demo.basic.model.mock.BlackBox
+import com.alibaba.demo.basic.model.mock.Box
+import com.alibaba.demo.basic.model.mock.Color
 
 /**
  * 演示父类变量引用子类对象时的Mock场景

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/DemoInnerClass.kt

@@ -0,0 +1,49 @@
+package com.alibaba.demo.basic
+
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executors
+
+/**
+ * 演示对内部类的Mock支持
+ * Demonstrate support for mocking invocation inside a inner class
+ */
+class DemoInnerClass {
+
+    class StaticInner {
+        /**
+         * invocation inside a static inner class
+         */
+        fun demo(): String {
+            return methodToBeMock()
+        }
+    }
+
+    inner class Inner {
+        /**
+         * invocation inside a non-static inner class
+         */
+        fun demo(): String {
+            return methodToBeMock()
+        }
+    }
+
+    private val executorService = Executors.newSingleThreadExecutor()
+    @Throws(ExecutionException::class, InterruptedException::class)
+    fun callAnonymousInner(): String {
+        /**
+         * invocation inside a anonymous inner class
+         */
+        val future = executorService.submit<String> { methodToBeMock() }
+        return future.get()
+    }
+
+    fun callInnerDemo(): String {
+        return Inner().demo()
+    }
+
+    companion object {
+        fun methodToBeMock(): String {
+            return "RealCall"
+        }
+    }
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/DemoMatcher.kt

@@ -1,6 +1,6 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
-import com.alibaba.testable.demo.model.BlackBox
+import com.alibaba.demo.basic.model.mock.BlackBox
 import java.util.*
 
 /**

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/DemoMock.kt

@@ -1,7 +1,7 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
-import com.alibaba.testable.demo.model.BlackBox
-import com.alibaba.testable.demo.model.ColorBox
+import com.alibaba.demo.basic.model.mock.BlackBox
+import com.alibaba.demo.basic.model.mock.ColorBox
 import java.nio.file.Files
 import java.nio.file.Paths
 

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/DemoPrivateAccess.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
 /**
  * 演示私有成员访问功能
@@ -9,7 +9,7 @@ class DemoPrivateAccess {
     /**
      * a private member field
      */
-    private var count = 0
+    var count = 0
 
     /**
      * a constant field
@@ -19,7 +19,7 @@ class DemoPrivateAccess {
     /**
      * private member method
      */
-    private fun privateFunc(list: List<String>, str: String, i: Int): String {
+    fun privateFunc(list: List<String>, str: String, i: Int): String {
         return list.reduce { a: String, s: String -> a + s } + " + " + "$str + $i"
     }
 
@@ -28,12 +28,12 @@ class DemoPrivateAccess {
         /**
          * a private static field
          */
-        private var staticCount = 0
+        var staticCount = 0
 
         /**
          * private static method
          */
-        private fun privateStaticFunc(str: String, i: Int): String {
+        fun privateStaticFunc(str: String, i: Int): String {
             return "$str + $i"
         }
 

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/DemoTemplate.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
 import java.util.ArrayList
 import java.util.HashMap

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/model/mock/BlackBox.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.model
+package com.alibaba.demo.basic.model.mock
 
 
 class BlackBox(var input: String) : Box(), Color {

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/model/mock/Box.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.model
+package com.alibaba.demo.basic.model.mock
 
 abstract class Box {
 

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/model/mock/Color.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.model
+package com.alibaba.demo.basic.model.mock
 
 interface Color {
 

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/model/omni/Child.kt

@@ -0,0 +1,20 @@
+package com.alibaba.demo.basic.model.omni
+
+/**
+ * 我是一个只有私有构造方法的类
+ * This class have only private constructor
+ */
+class Child private constructor() {
+
+    // ---------- 内部成员字段 ----------
+    var grandChild: GrandChild? = null
+    var subChild: InnerChild? = null
+
+    /**
+     * 这是一个私有内部类
+     * An private inner class
+     */
+    inner class InnerChild {
+        private val secret: String? = null
+    }
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/model/omni/GrandChild.kt

@@ -0,0 +1,9 @@
+package com.alibaba.demo.basic.model.omni
+
+class GrandChild {
+
+    // ---------- 内部成员字段 ----------
+    var value = 0
+    var content: String? = null
+
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/basic/model/omni/Parent.kt

@@ -0,0 +1,19 @@
+package com.alibaba.demo.basic.model.omni
+
+import java.lang.IllegalArgumentException
+
+/**
+ * 我是一个虽有构造方法，但无法正常构造的类
+ * This class have constructor with exception throw
+ */
+class Parent {
+
+    init {
+        throw IllegalArgumentException()
+    }
+
+    // ---------- 内部成员字段 ----------
+    var child: Child? = null
+    var children: Array<Child>? = null
+
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/java2kotlin/PathDemo.kt

@@ -1,9 +1,9 @@
-package com.alibaba.testable.demo.util
+package com.alibaba.demo.java2kotlin
 
 import java.io.File
 import java.io.IOException
 
-object PathUtil {
+object PathDemo {
 
     fun deleteRecursively(file: File) {
         if (!file.exists()) {

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/one2multi/ASvc.kt

@@ -0,0 +1,9 @@
+package com.alibaba.demo.one2multi
+
+class ASvc {
+
+    fun demo(name: String): String {
+        return String.format("a_%s", name)
+    }
+
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/one2multi/BSvc.kt

@@ -0,0 +1,9 @@
+package com.alibaba.demo.one2multi
+
+class BSvc {
+
+    fun demo(name: String): String {
+        return String.format("b_%s", name)
+    }
+
+}

demo/kotlin-demo/src/main/kotlin/com/alibaba/demo/one2multi/CSvc.kt

@@ -0,0 +1,9 @@
+package com.alibaba.demo.one2multi
+
+class CSvc {
+
+    fun demo(name: String): String {
+        return String.format("c_%s", name)
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/association/CookerServiceMock.kt

@@ -0,0 +1,27 @@
+package com.alibaba.demo.association
+
+import com.alibaba.testable.core.annotation.MockMethod
+import com.alibaba.testable.core.model.MockScope
+
+internal class CookerServiceMock {
+
+    @MockMethod(targetClass = CookerService::class)
+    private fun cookSandwich(): String {
+        return "Faked-Sandwich"
+    }
+
+    @MockMethod(targetClass = CookerService::class, scope = MockScope.ASSOCIATED)
+    private fun cookHamburger(): String {
+        return "Faked-Hamburger"
+    }
+
+    @MockMethod(targetClass = CookerService::class)
+    fun hireSandwichCooker(): String {
+        return "Fake-Sandwich-Cooker"
+    }
+
+    @MockMethod(targetClass = CookerService::class, scope = MockScope.ASSOCIATED)
+    fun hireHamburgerCooker(): String {
+        return "Fake-Hamburger-Cooker"
+    }
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/association/SellerServiceTest.kt

@@ -0,0 +1,19 @@
+package com.alibaba.demo.association
+
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class SellerServiceTest {
+
+    private val sellerService = SellerService()
+
+    @Test
+    fun should_sell_sandwich() {
+        Assertions.assertEquals("Fake-Sandwich-Cooker & Faked-Sandwich", sellerService.sellSandwich())
+    }
+
+    @Test
+    fun should_sell_hamburger() {
+        Assertions.assertEquals("Real-Hamburger-Cooker & Real-Hamburger", sellerService.sellHamburger())
+    }
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoInheritTest.kt

@@ -0,0 +1,92 @@
+package com.alibaba.demo.basic
+
+import com.alibaba.testable.core.annotation.MockMethod
+import com.alibaba.testable.core.matcher.InvokeVerifier
+import com.alibaba.demo.basic.model.mock.BlackBox
+import com.alibaba.demo.basic.model.mock.Box
+import com.alibaba.demo.basic.model.mock.Color
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+/**
+ * 演示父类变量引用子类对象时的Mock场景
+ * Demonstrate scenario of mocking method from sub-type object referred by parent-type variable
+ */
+internal class DemoInheritTest {
+
+    private val demoInherit = com.alibaba.demo.basic.DemoInherit()
+
+    class Mock {
+        @MockMethod(targetMethod = "put")
+        private fun put_into_box(self: Box, something: String) {
+            self.put("put_" + something + "_into_box")
+        }
+
+        @MockMethod(targetMethod = "put")
+        private fun put_into_blackbox(self: BlackBox, something: String) {
+            self.put("put_" + something + "_into_blackbox")
+        }
+
+        @MockMethod(targetMethod = "get")
+        private fun get_from_box(self: Box): String {
+            return "get_from_box"
+        }
+
+        @MockMethod(targetMethod = "get")
+        private fun get_from_blackbox(self: BlackBox): String {
+            return "get_from_blackbox"
+        }
+
+        @MockMethod(targetMethod = "getColor")
+        private fun get_color_from_color(self: Color): String {
+            return "color_from_color"
+        }
+
+        @MockMethod(targetMethod = "getColor")
+        private fun get_color_from_blackbox(self: BlackBox): String {
+            return "color_from_blackbox"
+        }
+    }
+
+    @Test
+    fun should_mock_call_sub_object_method_by_parent_object() {
+        val box = demoInherit.putIntoBox() as BlackBox
+        InvokeVerifier.verify("put_into_box").withTimes(1)
+        Assertions.assertEquals("put_data_into_box", box.get())
+    }
+
+    @Test
+    fun should_mock_call_sub_object_method_by_sub_object() {
+        val box = demoInherit.putIntoBlackBox()
+        InvokeVerifier.verify("put_into_blackbox").withTimes(1)
+        Assertions.assertEquals("put_data_into_blackbox", box.get())
+    }
+
+    @Test
+    fun should_mock_call_parent_object_method_by_parent_object() {
+        val content = demoInherit.fromBox
+        InvokeVerifier.verify("get_from_box").withTimes(1)
+        Assertions.assertEquals("get_from_box", content)
+    }
+
+    @Test
+    fun should_mock_call_parent_object_method_by_sub_object() {
+        val content = demoInherit.fromBlackBox
+        InvokeVerifier.verify("get_from_blackbox").withTimes(1)
+        Assertions.assertEquals("get_from_blackbox", content)
+    }
+
+    @Test
+    fun should_mock_call_interface_method_by_interface_object() {
+        val color = demoInherit.colorViaColor
+        InvokeVerifier.verify("get_color_from_color").withTimes(1)
+        Assertions.assertEquals("color_from_color", color)
+    }
+
+    @Test
+    fun should_mock_call_interface_method_by_sub_class_object() {
+        val color = demoInherit.colorViaBox
+        InvokeVerifier.verify("get_color_from_blackbox").withTimes(1)
+        Assertions.assertEquals("color_from_blackbox", color)
+    }
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoInnerClassTest.kt

@@ -0,0 +1,28 @@
+package com.alibaba.demo.basic
+
+import com.alibaba.testable.core.annotation.MockMethod
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+/**
+ * 演示对内部类的Mock支持
+ * Demonstrate support for mocking invocation inside a inner class
+ */
+internal class DemoInnerClassTest {
+
+    class Mock {
+        @MockMethod(targetClass = DemoInnerClass::class)
+        fun methodToBeMock(): String {
+            return "MockedCall"
+        }
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun should_mock_invoke_inside_inner_class() {
+        val demo = DemoInnerClass()
+        Assertions.assertEquals("MockedCall", demo.callInnerDemo())
+        Assertions.assertEquals("MockedCall", demo.callAnonymousInner())
+        Assertions.assertEquals("MockedCall", DemoInnerClass.StaticInner().demo())
+    }
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoMatcherTest.kt

@@ -1,10 +1,10 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
 import com.alibaba.testable.core.annotation.MockMethod
 import com.alibaba.testable.core.error.VerifyFailedError
 import com.alibaba.testable.core.matcher.InvokeMatcher
 import com.alibaba.testable.core.matcher.InvokeVerifier
-import com.alibaba.testable.demo.model.BlackBox
+import com.alibaba.demo.basic.model.mock.BlackBox
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 
@@ -14,21 +14,22 @@ import org.junit.jupiter.api.Test
  */
 internal class DemoMatcherTest {
 
-    private val demoMatcher = DemoMatcher()
+    private val demoMatcher = com.alibaba.demo.basic.DemoMatcher()
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private fun methodWithoutArgument(self: DemoMatcher) {
+    class Mock {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithoutArgument(self: com.alibaba.demo.basic.DemoMatcher) {
+        }
+
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithArguments(self: com.alibaba.demo.basic.DemoMatcher, a1: Any, a2: Any) {
+        }
+
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithArrayArgument(self: com.alibaba.demo.basic.DemoMatcher, a: Array<Any>) {
+        }
     }
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private fun methodWithArguments(self: DemoMatcher, a1: Any, a2: Any) {
-    }
-
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private fun methodWithArrayArgument(self: DemoMatcher, a: Array<Any>) {
-    }
-
-
     @Test
     fun should_match_no_argument() {
         demoMatcher.callMethodWithoutArgument()

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoMockTest.kt

@@ -1,12 +1,12 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
 import com.alibaba.testable.core.annotation.MockConstructor
 import com.alibaba.testable.core.annotation.MockMethod
 import com.alibaba.testable.core.matcher.InvokeVerifier.verify
 import com.alibaba.testable.core.tool.TestableTool.SOURCE_METHOD
 import com.alibaba.testable.core.tool.TestableTool.MOCK_CONTEXT
-import com.alibaba.testable.demo.model.BlackBox
-import com.alibaba.testable.demo.model.ColorBox
+import com.alibaba.demo.basic.model.mock.BlackBox
+import com.alibaba.demo.basic.model.mock.ColorBox
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import java.util.concurrent.Executors
@@ -19,70 +19,71 @@ internal class DemoMockTest {
 
     private val demoMock = DemoMock()
 
-    @MockConstructor
-    private fun createBlackBox(text: String) = BlackBox("mock_$text")
+    class Mock {
+        @MockConstructor
+        private fun createBlackBox(text: String) = BlackBox("mock_$text")
 
-    @MockMethod(targetClass = DemoMock::class)
-    private fun innerFunc(text: String) = "mock_$text"
+        @MockMethod(targetClass = DemoMock::class)
+        private fun innerFunc(text: String) = "mock_$text"
 
-    @MockMethod(targetClass = DemoMock::class)
-    private fun staticFunc(): String {
-        return "_MOCK_TAIL";
-    }
+        @MockMethod(targetClass = DemoMock::class)
+        private fun staticFunc(): String {
+            return "_MOCK_TAIL";
+        }
 
-    @MockMethod(targetClass = BlackBox::class)
-    private fun trim() = "trim_string"
+        @MockMethod(targetClass = BlackBox::class)
+        private fun trim() = "trim_string"
 
-    @MockMethod(targetClass = BlackBox::class, targetMethod = "substring")
-    private fun sub(i: Int, j: Int) = "sub_string"
+        @MockMethod(targetClass = BlackBox::class, targetMethod = "substring")
+        private fun sub(i: Int, j: Int) = "sub_string"
 
-    @MockMethod(targetClass = BlackBox::class)
-    private fun startsWith(s: String) = false
+        @MockMethod(targetClass = BlackBox::class)
+        private fun startsWith(s: String) = false
 
-    @MockMethod(targetClass = BlackBox::class)
-    private fun secretBox(): BlackBox {
-        return BlackBox("not_secret_box")
-    }
+        @MockMethod(targetClass = BlackBox::class)
+        private fun secretBox(): BlackBox {
+            return BlackBox("not_secret_box")
+        }
 
-    @MockMethod(targetClass = ColorBox::class)
-    private fun createBox(color: String, box: BlackBox): BlackBox {
-        return BlackBox("White_${box.get()}")
-    }
+        @MockMethod(targetClass = ColorBox::class)
+        private fun createBox(color: String, box: BlackBox): BlackBox {
+            return BlackBox("White_${box.get()}")
+        }
 
-    @MockMethod(targetClass = DemoMock::class)
-    private fun callFromDifferentMethod(): String {
-        return if (MOCK_CONTEXT["case"] == "special_case") {
-            "mock_special"
-        } else {
-            when (SOURCE_METHOD) {
-                "callerOne" -> "mock_one"
-                else -> "mock_others"
+        @MockMethod(targetClass = DemoMock::class)
+        private fun callFromDifferentMethod(): String {
+            return if (MOCK_CONTEXT["case"] == "special_case") {
+                "mock_special"
+            } else {
+                when (SOURCE_METHOD) {
+                    "callerOne" -> "mock_one"
+                    else -> "mock_others"
+                }
             }
         }
     }
 
-
     @Test
-    fun should_able_to_mock_new_object() {
+    fun should_mock_new_object() {
         assertEquals("mock_something", demoMock.newFunc())
         verify("createBlackBox").with("something")
     }
 
     @Test
-    fun should_able_to_mock_member_method() {
+    fun should_mock_member_method() {
         assertEquals("{ \"res\": \"mock_hello_MOCK_TAIL\"}", demoMock.outerFunc("hello"))
         verify("innerFunc").with("hello")
         verify("staticFunc").with()
     }
 
 //    @Test
-//    fun should_able_to_mock_method_in_companion_object() {
+//    fun should_mock_method_in_companion_object() {
 //        assertEquals("CALL_MOCK_TAIL", DemoMock.callStaticFunc())
 //        verify("staticFunc").with()
 //    }
 
     @Test
-    fun should_able_to_mock_common_method() {
+    fun should_mock_common_method() {
         assertEquals("trim_string__sub_string__false", demoMock.commonFunc())
         verify("trim").withTimes(1)
         verify("sub").withTimes(1)
@@ -90,14 +91,14 @@ internal class DemoMockTest {
     }
 
     @Test
-    fun should_able_to_mock_static_method() {
+    fun should_mock_static_method() {
         assertEquals("White_not_secret_box", demoMock.getBox().get())
         verify("secretBox").withTimes(1)
         verify("createBox").withTimes(1)
     }
 
     @Test
-    fun should_able_to_get_source_method_name() {
+    fun should_get_source_method_name() {
         // synchronous
         assertEquals("mock_one_mock_others", demoMock.callerOne() + "_" + demoMock.callerTwo())
         // asynchronous
@@ -108,7 +109,7 @@ internal class DemoMockTest {
     }
 
     @Test
-    fun should_able_to_get_test_case_name() {
+    fun should_get_test_case_name() {
         MOCK_CONTEXT["case"] = "special_case"
         // synchronous
         assertEquals("mock_special", demoMock.callerOne())

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoOmniMethodsTest.kt

@@ -0,0 +1,86 @@
+package com.alibaba.demo.basic
+
+import com.alibaba.demo.basic.model.omni.Child
+import com.alibaba.demo.basic.model.omni.Parent
+import com.alibaba.testable.core.tool.OmniAccessor
+import com.alibaba.testable.core.tool.OmniConstructor
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+/**
+ * 演示快速创建任意对象和使用路径访问成员
+ * Demonstrate quick object construction and access members by path
+ */
+internal class DemoOmniMethodsTest {
+
+    @Test
+    fun should_construct_any_class() {
+        val parent = OmniConstructor.newInstance(Parent::class.java)
+
+        // 任意深度的子孙成员对象都不为空
+        Assertions.assertNotNull(parent.child?.grandChild?.content)
+
+        // 所有基础类型初始化为默认数值
+        Assertions.assertEquals(0, parent.child?.grandChild?.value)
+        Assertions.assertEquals("", parent.child?.grandChild?.content)
+
+        // 所有数组类型初始化为空数组
+        Assertions.assertEquals(0, parent.children?.size)
+    }
+
+    @Test
+    fun should_get_any_member() {
+        val parent = OmniConstructor.newInstance(Parent::class.java)
+        parent.children = OmniConstructor.newArray(Child::class.java, 3)
+        parent.child?.grandChild?.content = "from child"
+        parent.children?.get(0)?.grandChild?.content = "from 1st children"
+        parent.children?.get(1)?.grandChild?.content = "from 2nd children"
+        parent.children?.get(2)?.grandChild?.content = "from 3rd children"
+
+        // 使用成员名称快速读取成员对象
+        var contents = OmniAccessor.get<String?>(parent, "content")
+        Assertions.assertEquals(4, contents.size)
+        Assertions.assertEquals("from child", contents[0])
+        Assertions.assertEquals("from 1st children", contents[1])
+        Assertions.assertEquals("from 2nd children", contents[2])
+        Assertions.assertEquals("from 3rd children", contents[3])
+
+        // 使用成员类型快速读取成员对象
+        contents = OmniAccessor.get(parent, "{Child}/{GrandChild}/content")
+        Assertions.assertEquals(1, contents.size)
+        Assertions.assertEquals("from child", contents[0])
+
+        // 使用带下标的路径读取成员对象
+        Assertions.assertEquals("from 2nd children", OmniAccessor.getFirst(parent, "children[1]/{GrandChild}/content"))
+        Assertions.assertEquals("from 3rd children", OmniAccessor.getFirst(parent, "{Child[]}[2]/{GrandChild}/content"))
+
+        // 使用模糊路径快速读取成员对象
+        Assertions.assertEquals("from 1st children", OmniAccessor.getFirst(parent, "{C*[]}[0]/*/con*t"))
+    }
+
+    @Test
+    fun should_set_any_member() {
+        val parent = OmniConstructor.newInstance(Parent::class.java)
+        parent.children = OmniConstructor.newArray(Child::class.java, 3)
+
+        // 使用指定路径快速给成员对象赋值
+        OmniAccessor.set(parent, "child/grandChild/content", "demo child")
+        Assertions.assertEquals("demo child", parent.child?.grandChild?.content)
+
+        // 使用带下标的路径给成员对象赋值
+        OmniAccessor.set(parent, "children[1]/grandChild/content", "demo children[1]")
+        Assertions.assertEquals("demo children[1]", parent.children?.get(1)?.grandChild?.content)
+
+        // 使用模糊路径批量给成员对象赋值
+        OmniAccessor.set(parent, "child*/*/content", "demo in batch")
+        Assertions.assertEquals("demo in batch", parent.child?.grandChild?.content)
+        Assertions.assertEquals("demo in batch", parent.children?.get(0)?.grandChild?.content)
+        Assertions.assertEquals("demo in batch", parent.children?.get(1)?.grandChild?.content)
+        Assertions.assertEquals("demo in batch", parent.children?.get(2)?.grandChild?.content)
+
+        // 读写私有内部类类型的成员（使用类型名引用内部类时，无需带外部类名）
+        Assertions.assertEquals("", OmniAccessor.getFirst(parent, "subChild/secret"))
+        OmniAccessor.set(parent, "{InnerChild}/secret", "inner-class secret")
+        Assertions.assertEquals("inner-class secret", OmniAccessor.getFirst(parent, "subChild/secret"))
+    }
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoPrivateAccessorTest.kt

@@ -1,6 +1,6 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
-import com.alibaba.testable.core.accessor.PrivateAccessor
+import com.alibaba.testable.core.tool.PrivateAccessor
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
@@ -8,37 +8,37 @@ import org.junit.jupiter.api.Test
  * 演示私有成员访问功能
  * Demonstrate private member access functionality
  */
-internal class DemoPrivateAccessTest {
+internal class DemoPrivateAccessorTest {
 
     private val demoPrivateAccess = DemoPrivateAccess()
 
     @Test
-    fun should_able_to_access_private_method() {
+    fun should_access_private_method() {
         val list = listOf("a", "b", "c");
         assertEquals("abc + hello + 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc", list, "hello", 1))
     }
 
     @Test
-    fun should_able_to_access_private_field() {
+    fun should_access_private_field() {
         PrivateAccessor.set(demoPrivateAccess, "count", 3)
         assertEquals(3, PrivateAccessor.get(demoPrivateAccess, "count"))
     }
 
     @Test
-    fun should_able_to_access_private_static_method() {
+    fun should_access_private_static_method() {
         val list = listOf("a", "b", "c");
         assertEquals("hello + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess::class.java, "privateStaticFunc", "hello", 1))
         assertEquals("abc * hello * 1", PrivateAccessor.invokeStatic(DemoPrivateAccess::class.java, "privateJvmStaticFunc", list, "hello", 1))
     }
 
     @Test
-    fun should_able_to_access_private_static_field() {
+    fun should_access_private_static_field() {
         PrivateAccessor.setStatic(DemoPrivateAccess::class.java, "staticCount", 3)
         assertEquals(3, PrivateAccessor.getStatic(DemoPrivateAccess::class.java, "staticCount"))
     }
 
     @Test
-    fun should_able_to_update_final_field() {
+    fun should_update_final_field() {
         PrivateAccessor.set(demoPrivateAccess, "pi", 4.13)
         assertEquals(4.13, demoPrivateAccess.pi)
     }

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/basic/DemoTemplateTest.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
 import com.alibaba.testable.core.annotation.MockConstructor
 import com.alibaba.testable.core.annotation.MockMethod
@@ -14,44 +14,45 @@ internal class DemoTemplateTest {
 
     private val demoTemplate = DemoTemplate()
 
-    @MockMethod
-    private fun <T> getList(self: DemoTemplate, value: T): List<T> {
-        return mutableListOf((value.toString() + "_mock_list") as T)
-    }
+    class Mock {
+        @MockMethod
+        private fun <T> getList(self: DemoTemplate, value: T): List<T> {
+            return mutableListOf((value.toString() + "_mock_list") as T)
+        }
 
-    @MockMethod
-    private fun <K, V> getMap(self: DemoTemplate, key: K, value: V): Map<K, V> {
-        return mutableMapOf(key to (value.toString() + "_mock_map") as V)
-    }
+        @MockMethod
+        private fun <K, V> getMap(self: DemoTemplate, key: K, value: V): Map<K, V> {
+            return mutableMapOf(key to (value.toString() + "_mock_map") as V)
+        }
 
-    @MockConstructor
-    private fun newHashSet(): HashSet<*> {
-        val set = HashSet<Any>()
-        set.add("insert_mock")
-        return set
-    }
+        @MockConstructor
+        private fun newHashSet(): HashSet<*> {
+            val set = HashSet<Any>()
+            set.add("insert_mock")
+            return set
+        }
 
-    @MockMethod
-    private fun <E> add(s: MutableSet<E>, e: E): Boolean {
-        s.add((e.toString() + "_mocked") as E)
-        return true
+        @MockMethod
+        private fun <E> add(s: MutableSet<E>, e: E): Boolean {
+            s.add((e.toString() + "_mocked") as E)
+            return true
+        }
     }
 
-
     @Test
-    fun should_able_to_mock_single_template_method() {
+    fun should_mock_single_template_method() {
         val res = demoTemplate.singleTemplateMethod()
         Assertions.assertEquals("demo_mock_list", res)
     }
 
     @Test
-    fun should_able_to_mock_double_template_method() {
+    fun should_mock_double_template_method() {
         val res = demoTemplate.doubleTemplateMethod()
         Assertions.assertEquals("testable_mock_map", res)
     }
 
     @Test
-    fun should_able_to_mock_new_template_method() {
+    fun should_mock_new_template_method() {
         val res = demoTemplate.newTemplateMethod()
         Assertions.assertEquals(2, res.size)
         val iterator = res.stream().iterator()

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/java2kotlin/PathDemoTest.kt

@@ -0,0 +1,50 @@
+package com.alibaba.demo.java2kotlin
+
+import com.alibaba.testable.core.annotation.MockMethod
+import com.alibaba.testable.core.matcher.InvokeVerifier.verify
+import org.junit.jupiter.api.Test
+import java.io.File
+
+class PathDemoTest {
+
+    class Mock {
+        @MockMethod
+        fun exists(f: File): Boolean {
+            return when (f.absolutePath) {
+                "/a/b" -> true
+                "/a/b/c" -> true
+                else -> f.exists()
+            }
+        }
+
+        @MockMethod
+        fun isDirectory(f: File): Boolean {
+            return when (f.absolutePath) {
+                "/a/b/c" -> true
+                else -> f.isDirectory
+            }
+        }
+
+        @MockMethod
+        fun delete(f: File): Boolean {
+            return true
+        }
+
+        @MockMethod
+        fun listFiles(f: File): Array<File>? {
+            return when (f.absolutePath) {
+                "/a/b" -> arrayOf(File("/a/b/c"), File("/a/b/d"))
+                "/a/b/c" -> arrayOf(File("/a/b/c/e"))
+                else -> f.listFiles()
+            }
+        }
+    }
+
+    @Test
+    fun should_mock_java_method_invoke_in_kotlin() {
+        PathDemo.deleteRecursively(File("/a/b/"))
+        verify("listFiles").withTimes(2)
+        verify("delete").withTimes(4)
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/one2multi/ASvcMock.kt

@@ -0,0 +1,12 @@
+package com.alibaba.demo.one2multi
+
+import com.alibaba.testable.core.annotation.MockMethod
+
+class ASvcMock {
+
+    @MockMethod(targetClass = String::class, targetMethod = "format")
+    fun a_format(format: String, vararg args: Any?): String {
+        return "a_mock"
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/one2multi/BSvcMock.kt

@@ -0,0 +1,12 @@
+package com.alibaba.demo.one2multi
+
+import com.alibaba.testable.core.annotation.MockMethod
+
+class BSvcMock {
+
+    @MockMethod(targetClass = String::class, targetMethod = "format")
+    fun b_format(format: String, vararg args: Any?): String {
+        return "b_mock"
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/one2multi/CSvcMock.kt

@@ -0,0 +1,12 @@
+package com.alibaba.demo.one2multi
+
+import com.alibaba.testable.core.annotation.MockMethod
+
+class CSvcMock {
+
+    @MockMethod(targetClass = String::class, targetMethod = "format")
+    fun c_format(format: String, vararg args: Any?): String {
+        return "c_mock"
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/one2multi/OneToMultiSvcTest.kt

@@ -0,0 +1,25 @@
+package com.alibaba.demo.one2multi
+
+import com.alibaba.testable.core.annotation.MockWith
+import com.alibaba.testable.core.matcher.InvokeVerifier.verify
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+@MockWith
+class OneToMultiSvcTest {
+
+    private val aSvc = ASvc()
+    private val bSvc = BSvc()
+    private val cSvc = CSvc()
+
+    @Test
+    fun should_test_multi_class_together() {
+        Assertions.assertEquals("a_mock", aSvc.demo("test"))
+        Assertions.assertEquals("b_mock", bSvc.demo("test"))
+        Assertions.assertEquals("c_mock", cSvc.demo("test"))
+        verify("a_format").withTimes(1)
+        verify("b_format").withTimes(1)
+        verify("c_format").withTimes(1)
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoInheritTest.kt

@@ -1,91 +0,0 @@
-package com.alibaba.testable.demo
-
-import com.alibaba.testable.core.annotation.MockMethod
-import com.alibaba.testable.core.matcher.InvokeVerifier
-import com.alibaba.testable.demo.model.BlackBox
-import com.alibaba.testable.demo.model.Box
-import com.alibaba.testable.demo.model.Color
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Test
-
-/**
- * 演示父类变量引用子类对象时的Mock场景
- * Demonstrate scenario of mocking method from sub-type object referred by parent-type variable
- */
-internal class DemoInheritTest {
-
-    private val demoInherit = DemoInherit()
-
-    @MockMethod(targetMethod = "put")
-    private fun put_into_box(self: Box, something: String) {
-        self.put("put_" + something + "_into_box")
-    }
-
-    @MockMethod(targetMethod = "put")
-    private fun put_into_blackbox(self: BlackBox, something: String) {
-        self.put("put_" + something + "_into_blackbox")
-    }
-
-    @MockMethod(targetMethod = "get")
-    private fun get_from_box(self: Box): String {
-        return "get_from_box"
-    }
-
-    @MockMethod(targetMethod = "get")
-    private fun get_from_blackbox(self: BlackBox): String {
-        return "get_from_blackbox"
-    }
-
-    @MockMethod(targetMethod = "getColor")
-    private fun get_color_from_color(self: Color): String {
-        return "color_from_color"
-    }
-
-    @MockMethod(targetMethod = "getColor")
-    private fun get_color_from_blackbox(self: BlackBox): String {
-        return "color_from_blackbox"
-    }
-
-
-    @Test
-    fun should_able_to_mock_call_sub_object_method_by_parent_object() {
-        val box = demoInherit.putIntoBox() as BlackBox
-        InvokeVerifier.verify("put_into_box").withTimes(1)
-        Assertions.assertEquals("put_data_into_box", box.get())
-    }
-
-    @Test
-    fun should_able_to_mock_call_sub_object_method_by_sub_object() {
-        val box = demoInherit.putIntoBlackBox()
-        InvokeVerifier.verify("put_into_blackbox").withTimes(1)
-        Assertions.assertEquals("put_data_into_blackbox", box.get())
-    }
-
-    @Test
-    fun should_able_to_mock_call_parent_object_method_by_parent_object() {
-        val content = demoInherit.fromBox
-        InvokeVerifier.verify("get_from_box").withTimes(1)
-        Assertions.assertEquals("get_from_box", content)
-    }
-
-    @Test
-    fun should_able_to_mock_call_parent_object_method_by_sub_object() {
-        val content = demoInherit.fromBlackBox
-        InvokeVerifier.verify("get_from_blackbox").withTimes(1)
-        Assertions.assertEquals("get_from_blackbox", content)
-    }
-
-    @Test
-    fun should_able_to_mock_call_interface_method_by_interface_object() {
-        val color = demoInherit.colorViaColor
-        InvokeVerifier.verify("get_color_from_color").withTimes(1)
-        Assertions.assertEquals("color_from_color", color)
-    }
-
-    @Test
-    fun should_able_to_mock_call_interface_method_by_sub_class_object() {
-        val color = demoInherit.colorViaBox
-        InvokeVerifier.verify("get_color_from_blackbox").withTimes(1)
-        Assertions.assertEquals("color_from_blackbox", color)
-    }
-}

demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/util/PathUtilTest.kt

@@ -1,48 +0,0 @@
-package com.alibaba.testable.demo.util
-
-import com.alibaba.testable.core.annotation.MockMethod
-import com.alibaba.testable.core.matcher.InvokeVerifier.verify
-import org.junit.jupiter.api.Test
-import java.io.File
-
-class PathUtilTest {
-
-    @MockMethod
-    fun exists(f: File): Boolean {
-        return when (f.absolutePath) {
-            "/a/b" -> true
-            "/a/b/c" -> true
-            else -> f.exists()
-        }
-    }
-
-    @MockMethod
-    fun isDirectory(f: File): Boolean {
-        return when (f.absolutePath) {
-            "/a/b/c" -> true
-            else -> f.isDirectory
-        }
-    }
-
-    @MockMethod
-    fun delete(f: File): Boolean {
-        return true
-    }
-
-    @MockMethod
-    fun listFiles(f: File): Array<File>? {
-        return when (f.absolutePath) {
-            "/a/b" -> arrayOf(File("/a/b/c"), File("/a/b/d"))
-            "/a/b/c" -> arrayOf(File("/a/b/c/e"))
-            else -> f.listFiles()
-        }
-    }
-
-    @Test
-    fun should_able_to_mock_java_method_invoke_in_kotlin() {
-        PathUtil.deleteRecursively(File("/a/b/"))
-        verify("listFiles").withTimes(2)
-        verify("delete").withTimes(4)
-    }
-
-}

demo/kotlin-demo/src/test/resources/testable.properties

@@ -0,0 +1 @@
+omni.constructor.enhance.enable = true

demo/pom.xml

@@ -12,6 +12,7 @@
   <modules>
     <module>java-demo</module>
     <module>kotlin-demo</module>
+    <module>spock-demo</module>
   </modules>
 
 </project>

demo/settings.gradle

@@ -0,0 +1,5 @@
+rootProject.name = 'demos'
+
+include 'java-demo'
+include 'kotlin-demo'
+include 'spock-demo'

demo/spock-demo/build.gradle

@@ -0,0 +1,28 @@
+plugins {
+    id 'groovy'
+}
+
+group = 'com.alibaba.testable'
+version = '1.0.0-SNAPSHOT'
+sourceCompatibility = '8'
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation 'org.codehaus.groovy:groovy-all:3.0.7'
+    testImplementation 'org.spockframework:spock-core:2.0-M5-groovy-3.0'
+    testImplementation('com.alibaba.testable:testable-all:0.6.5')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.5')
+}
+
+tasks.withType(JavaCompile) {
+    options.encoding = "UTF-8"
+}
+
+test {
+    jvmArgs "-javaagent:${classpath.find { it.name.contains("testable-agent") }.absolutePath}"
+    useJUnitPlatform()
+}

demo/spock-demo/pom.xml

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Refer to: https://github.com/spockframework/spock-example/blob/master/pom.xml -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.alibaba.testable</groupId>
+	<artifactId>spock-demo</artifactId>
+	<version>1.0.0-SNAPSHOT</version>
+	<name>spock-demo</name>
+	<description>Spock demo for Testable</description>
+	<properties>
+		<java.version>1.8</java.version>
+		<maven.compiler.source>1.8</maven.compiler.source>
+		<maven.compiler.target>1.8</maven.compiler.target>
+		<testable.version>0.6.5</testable.version>
+	</properties>
+
+	<dependencyManagement>
+		<dependencies>
+			<dependency>
+				<groupId>org.spockframework</groupId>
+				<artifactId>spock-bom</artifactId>
+				<version>2.0-M5-groovy-3.0</version>
+				<type>pom</type>
+				<scope>import</scope>
+			</dependency>
+		</dependencies>
+	</dependencyManagement>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.codehaus.groovy</groupId>
+			<artifactId>groovy</artifactId>
+			<version>3.0.7</version>
+		</dependency>
+		<dependency>
+			<groupId>org.spockframework</groupId>
+			<artifactId>spock-core</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.spockframework</groupId>
+			<artifactId>spock-junit4</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.alibaba.testable</groupId>
+			<artifactId>testable-all</artifactId>
+			<version>${testable.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<!-- The gmavenplus plugin is used to compile Groovy code -->
+				<groupId>org.codehaus.gmavenplus</groupId>
+				<artifactId>gmavenplus-plugin</artifactId>
+				<version>1.12.0</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>compile</goal>
+							<goal>compileTests</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>3.0.0-M5</version>
+				<configuration>
+					<argLine>-javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>
+					<useFile>false</useFile>
+					<includes>
+						<include>**/*Test.java</include>
+						<include>**/*Spec.java</include>
+					</includes>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>

demo/spock-demo/src/main/java/com/github/pbetkier/spockdemo/DemoSpock.java

@@ -0,0 +1,19 @@
+package com.github.pbetkier.spockdemo;
+
+import com.github.pbetkier.spockdemo.model.SpockBox;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.stream.Collectors;
+
+public class DemoSpock {
+
+    public SpockBox createBoxOfNum() {
+        SpockBox box = new SpockBox();
+        for (int i = 1; i <= 3; i++) {
+            box.put(String.valueOf(i));
+        }
+        return box;
+    }
+
+}

demo/spock-demo/src/main/java/com/github/pbetkier/spockdemo/model/SpockBox.java

@@ -0,0 +1,27 @@
+package com.github.pbetkier.spockdemo.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SpockBox {
+
+    private List<String> contents = new ArrayList<>();
+
+    public int size() {
+        return contents.size();
+    }
+
+    public void put(String data) {
+        contents.add(data);
+    }
+
+    public String pop() {
+        if (contents.isEmpty()) {
+            return null;
+        }
+        String data = contents.get(size() - 1);
+        contents.remove(size() - 1);
+        return data;
+    }
+
+}

demo/spock-demo/src/test/groovy/com/github/pbetkier/spockdemo/DemoSpockTest.groovy

@@ -0,0 +1,44 @@
+package com.github.pbetkier.spockdemo
+
+import com.alibaba.testable.core.annotation.MockConstructor
+import com.alibaba.testable.core.annotation.MockMethod
+import com.github.pbetkier.spockdemo.model.SpockBox
+import spock.lang.Shared
+import spock.lang.Specification
+
+import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
+
+class DemoSpockTest extends Specification {
+
+    @Shared
+    def demoSpock = new DemoSpock()
+
+    static class Mock {
+        @MockConstructor
+        SpockBox createBox() {
+            SpockBox box = new SpockBox()
+            box.put("mock zero")
+            return box
+        }
+
+        @MockMethod(targetMethod = "put")
+        void putBox(SpockBox self, String data) {
+            self.put("mock " + data)
+        }
+    }
+
+    def "should get a box of numbers"() {
+        given:
+        def box = demoSpock.createBoxOfNum()
+
+        expect:
+        box.size() == 4
+        box.pop() == "mock 3"
+        box.pop() == "mock 2"
+        box.pop() == "mock 1"
+        box.pop() == "mock zero"
+        verify("createBox").withTimes(1)
+        verify("putBox").withInOrder("1").withInOrder("2").withInOrder("3")
+    }
+
+}

docs/en-us/doc/annotations.md

@@ -0,0 +1,4 @@
+Available Annotations
+---
+
+TO BE TRANSLATED

docs/en-us/doc/comparation.md

@@ -23,4 +23,4 @@ The functionality of `TestabledMock` is basically the same as that of `PowerMock
 
 The main disadvantage of the current `TestableMock` is that the IDE cannot promptly prompt whether the method parameters are matched correctly when writing the mock method. If the mocking effect does not meet expectation, it has to be verified during runtime through the method provided in the [self-help troubleshooting](en-us/doc/troubleshooting.md) document. This feature needs to be provided by extending IDE plugins in the future.
 
-In addition, because `TestableMock` uses the mock mechanism based on a single method in a unique way, it decouples the mock method definition from the unit test cases. Thus, the mock methods are by default reusable, and the unit test cases become cleaner and purer. On the other hand, the mock methods become fragmented, and life cycle management is relatively difficult. Therefore, it may take some time for developers get used to it.
+In addition, because `TestableMock` uses the mechanism based on "each source class binding to its own mock class" in a unique way, it decouples the mock method definition from the unit test cases. Thus, the mock methods are by default reusable, and the unit test cases become cleaner and purer. On the other hand, the mock methods become fragmented, and life cycle management is relatively difficult. Therefore, it may take some time for developers get used to it.

docs/en-us/doc/design-and-mechanism.md

@@ -0,0 +1,29 @@
+How Mock Works
+---
+
+This document mainly introduces the design and implementation principles of the mock function in `TestableMock`.
+
+Unlike common mock-tools which write mock definitions in each test case, `TestableMock` allows each business class to provide its own set of mock methods, describing what should be mocked during testing, and define the corresponding replacement logic (that is, each business class has its own independent "Test class" and independent "Mock class"). By adopting "convention is better than configuration" principle, `TestableMock` not only reduce redundant codes but also reduce the cost of mock learning.
+
+This design is based on two basic assumptions:
+
+1. In any business class, methods that need to be mocked in one test case are usually required to be mocked in other test cases. For these mocked methods usually requiring external dependencies that are not easy to test.
+2. Each unit test only focuses on the logic inside the unit under test, and irrelevant calls outside the unit should be replaced with mocks. That is, the invocations that need to be mocked should all be in the code of the class under test.
+
+Accordingly, the unit test scenarios that meet the above assumptions are simplified through conventions, and the remaining more complex use scenarios are supported through configuration.
+
+The mechanism of `TestableMock` can be summarized in one sentence: <u>Using java agent to dynamically modify the bytecode, before the unit test is about to run, replace all invocations in the business class under test which match the mock method definition with invocations to the mock method itself.</u>.
+
+The final effect is that no matter what service framework or object-container the code uses, no matter whether the object of mock target is injected by a framework, created by new operation, and whether the target method of mock is private or external, defined as global, local, static, inherited or overloaded, all can be mocked in a same and simple way, which make unit testing much easier.
+
+> Notice: Mock's goal is the method invocation in the class under test. The code inside the test case will not be mocked, and the method definition itself has not changed, but the invocation code to those methods will be replaced.
+
+Specifically, when the unit test is started, `TestableMock` will preprocess the classes loaded into memory and establish the association relationship between the "class under test", the "test class", and the "mock container class" respectively (can be one-to-one or many-to-one). On the one hand, this association is to correctly match the mock call and replace it before the test case is executed, and on the other hand, it is used to control the effective scope of the mock method.
+
+For the class under test, replace the matched call with a call to the mock container method.
+
+For the test class, insert the mock context initialization code at the beginning of each test case.
+
+For the mock container class, add the `testableIns()` method to make the class become a singleton class, and insert codes to record the call at the beginning of each Mock method.
+
+The above is the core logic of the entire mocking logic. For more implementation details, please refer to the source code. If you have any questions, suggestions, or improvement proposals, you are welcome to participate in the discussion and contribute through Github Issue and Pull Request 😃

docs/en-us/doc/frequently-asked-questions.md

@@ -11,7 +11,15 @@ Create the class under test object directly, and then use the ability of `Testab
 
 For mock tools that modify the class loader or the bytecode of the class under test, such as `PowerMock` and `JMockit`, there is no yet case to prove that they will conflict with `TestableMock`, but in principle, there may be a risk of incompatibility between the two, Please use with caution.
 
-#### 3. How to implement the mock method when the parent class variable points to the child class object?
+#### 3. Which test frameworks does `TestableMock` support?
+
+The `PrivateAccessor` / `OmniConstructor` / `OmniAccessor` and basic functionality of `TestableMock` are theoretically test-frameworks-independent, and should work with any test frameworks out-of-box.
+
+The only test-framework-related part is the mock invocation verifier, which currently supports `JUnit 4` / `JUnit 5` / `TestNG` and `Spock` appropriately.
+
+If you encounter compatibility problem under a specific test framework, or want to add mock invocation verifier support for any other frameworks, please raise an [issue](https://github.com/alibaba/testable-mock/issues) to tell us.
+
+#### 4. How to implement the mock method when the parent class variable points to the child class object?
 
 In the code, there are often cases of using <u>interface variables or parent class variables</u> to point to an instance of subclasses and calling methods provided by the parent class or subclass.
 
@@ -21,7 +29,7 @@ Therefore, regardless of whether the actually called method comes from the paren
 
 See the use case of the `DemoInheritTest` test class in the Java and Kotlin examples.
 
-#### 4. How to mock generic methods (template methods)?
+#### 5. How to mock generic methods (template methods)?
 
 Just use the same generic parameters directly on the mock method.
 
@@ -29,44 +37,24 @@ See the use case of the `DemoTemplateTest` test class in the Java and Kotlin exa
 
 > Because JVM has a generic erasure mechanism, you can also directly use the `Object` type to replace generic parameters for Java projects, see the commented out "Second solution" example in the Java version of the `DemoTemplateTest` test class.
 
-#### 5. Why mocking methods in the `String` class in the Kotlin project does not work?
+#### 6. How to mock invocation inside an inner class?
+
+Just put mock methods in the mock container class of its outer class, it works for code in all inner classes.
+
+See the use case of the `DemoInnerClass` test class in the Java and Kotlin examples.
+
+#### 7. Why mocking methods in the `String` class in the Kotlin project does not work?
 
 The `String` type in Kotlin language is actually `kotlin.String` instead of `java.lang.String`. However, when this type is built from bytecode, it will be replaced with Java's `java.lang.String` class, so no matter if the mock target is written as `kotlin.String` or `java.lang.String`, it cannot match the original called method.
 
 In actual scenarios, there are very few scenarios where methods in the `String` class need to be mocked, so `TestableMock` has not dealt with this situation specifically.
 
-#### 6. Will the mock definition still be valid when it is **indirectly called** from other test classes?
-
-Equally effective, the scope of mock is the entire test runtime process.
-
-For example, some private methods and external invocation in the `Aaa` class are mocked, mock method are defined in the test class `AaaTest`. When testing the `Bbb` class in another test class `BbbTest`, some mocked methods are invoked indirectly in the `Aaa` class, the actual call will also be routed to the mock method defined in the `AaaTest` class.
-
-#### 7. Can `TestableMock` be used for testing Android projects?
+#### 8. Can `TestableMock` be used for testing Android projects?
 
 It can be used in combination with [Roboelectric](https://github.com/robolectric/robolectric) testing framework.
 
 The `Dalvik` and `ART` virtual machines of the Android system use a bytecode system different from the standard JVM, which will affect the normal functionality of `TestableMock`. The `Roboelectric` framework can run Android unit tests on a standard JVM virtual machine, which is much faster than running unit tests through the Android virtual machine. Recently, most Android App unit tests are written with the `Roboelectric` framework.
 
-#### 8. Meet "Attempt to access non-static member in mock method" error during mocking？
-
-The current design of `TestableMock` does not allow access to the non-`static` members of the test class in the mock method (because the mock method itself will be dynamically modified to the `static` type during runtime). However, some Java statements include building blocks (like `new ArrayList<String>() {{ append("data"); }}`), lambda expression (like `list.stream().map(i -> i. get)`) and so on, will generate additional member method invocations during compilation, causing mock method execution report above error.
-
-The simplest solution is to declare the mock method itself as a `static` type (so that dynamically generated invocation will also be `static` to avoid the errors), for example, the original method is defined as:
-
-```java
-@MockMethod
-private int getXxx(Demo self) {}
-```
-
-Modify it to：
-
-```java
-@MockMethod
-private static int getXxx(Demo self) {}
-```
-
-In the next major iteration (**i.e. `v0.5`**), the mock implementation mechanism will be modified while maintaining the current mock experience. Then, it will be no longer necessary to modify the mock method to a static method, and completely solving this problem.
-
 #### 9. Meet "Command Line is too Long. Shorten command line for ..." error when triggering test in IntelliJ IDE?
 
 This problem is caused by the system `Class Path` content is too long, and has nothing to do with `TestableMock`. However, it should be noted that IntelliJ provides two auxiliary solutions: `JAR manifest` and `classpath file`. If `TestableMock` is used in the test, please select `JAR manifest`.

docs/en-us/doc/javaagent-args.md

@@ -0,0 +1,4 @@
+Available Global Arguments
+---
+
+TO BE TRANSLATED

docs/en-us/doc/mock-method-reusing.md

@@ -0,0 +1,4 @@
+Reusing Mock Methods
+---
+
+TO BE TRANSLATED

docs/en-us/doc/omni-constructor.md

@@ -0,0 +1,117 @@
+Parameter Constructor
+---
+
+In unit testing, the preparation and construction of test data is a necessary and tedious task. Object-oriented layer-by-layer encapsulation becomes an obstacle to initializing the state of the object during testing. Especially when the type structure is complicated, there is no suitable construction method, or some fields need to use private inner classes, etc. Using conventional methods to construct those class often appear to be inadequate.
+
+For this reason, `TestableMock` provides two minimalist tool classes, `OmniConstructor` and `OmniAccessor`, which makes the construction of any object no longer difficult.
+
+### 1. Construct any object with one line of code
+
+No matter how special the target type is, `OmniConstructor` will hand it to you immediately~~ The universal object constructor `OmniConstructor` has two static methods:
+
+- `newInstance(<AnyClass>)` ➜ Specify any type, and return an object of that type
+- `newArray(<AnyClass>, <ArraySize>)` ➜ Specify any type, and return an array of that type
+
+Usage example:
+
+```java
+// Construct a object of "WhatEverClass" type
+WhatEverClass obj = OmniConstructor.newInstance(WhatEverClass.class);
+// Construct a array of "WhatEverClass[]" type with capability of 5
+WhatEverClass[] arr = OmniConstructor.newArray(WhatEverClass.class, 5);
+```
+
+Beside that, object constructed by `OmniConstructor` is not just a simple empty object with all member values of `null`, but a "fullness" object in which all members and all sub-members of all members have been recursively initialized. Compared with using `new` operation, `OmniConstructor` can ensure the integrity of the object structure and avoid the `NullPointerException` problem caused by partial initialization of test data.
+
+```java
+// Construct object using new operation
+Parent parent = new Parent();
+// Inner member is not initialized, will cause NullPointerException (❌)
+parent.getChild().getGrandChild();
+
+// Construct object using OmniConstructor
+Parent parent = OmniConstructor.newInstance(Parent.class);
+// No need to worry, visit any child member safely (✅)
+parent.getChild().getGrandChild().getContent();
+```
+
+> **Note 1**: In the current version, the member fields of type interface or abstract class will still be initialized to `null`, this problem will be fixed in the future.
+>
+> **Note 2**: Based on the light-weight principle, in the default mode, `OmniConstructor` will only uses the original constructor of the class to create objects. For POJO and most model layer objects, this mode has been able to meet the needs.
+> But for more complex situations, such as when certain class have constructors throwing exceptions or contain other statements that hinder the normal execution of the construction, the object construction may fail.
+> In those situations, you can use the [Testable global configuration](en-us/doc/javaagent-args.md) `omni.constructor.enhance.enable = true` to enable bytecode enhancement mode of `OmniConstructor`, in this mode, any Java class can be constructed.
+
+In addition to use as input parameters of the method under test, `OmniConstructor` can also be used to quickly construct the return value of the mock method. Compared to using `null` as the return value of the mock method, using a fully initialized object can better guarantee the reliability of the test .
+
+In the `DemoOmniMethodsTest` test class of the `java-demo` and `kotlin-demo` sample projects, it is shown in detail how `OmniConstructor` could be used when the target type has a multi-layered nested structure, the construction method is throwing exception, and even without public construction method available.
+
+### 2. Access any inner member with one line of code
+
+For test data, even with complex structure, it is usually only part of its attributes and states that are related to a specific test case. However, it is sometimes not easy to assign values to these fields deep wrapped in the object structure.
+
+As an enhanced version of the `PrivateAccessor` tool, `OmniAccessor` is inspired by the [XPath node selector](https://www.w3schools.com/xml/xpath_syntax.asp) in the `XML` language, It provides two main static methods of `get` and `set`:
+
+- `get(arbitrary object, "access path")` ➜ returns all member objects searched for based on path-matching
+- `set(arbitrary object, "access path", new value)` ➜ Assign a value to any objects based on path-matching
+
+There is also a `getFirst()` method used to directly obtain the unique target object during exact path matching. Its function is equivalent to `OmniAccessor.get(...).get(0)`:
+
+- `getFirst(arbitrary object, "access path")` ➜ returns the first member object searched based on path-matching
+
+You only need to write the access path that meets the rules, no matter what type and depth of members, you can directly reach them with one line of code:
+
+```java
+// Get all field of the parent object, which named as content and inside type GrandChild
+OmniAccessor.get(parent, "{GrandChild}/content");
+// Assign 100 to any fields which named as value and inside any child member that matches the 3rd item of the array named children
+OmniAccessor.set(parent, "children[2]/*/value", 100);
+```
+
+The path rules are as follows:
+
+**1. Matching member name**
+
+The path name without additional decoration will match any member object with the same name
+
+- `child`: match any descendant member whose name is `child`
+- `child/grandChild`: matches the child member named `grandChild` among the descendants of the name `child`
+
+**2. Matching member type**
+
+Use curly braces to match the type name, usually used to obtain or assign multiple member objects of the same type in batches
+
+- `{Child}`: match all descendants of `Child`
+- `{Children[]}`: match all descendants of the `Children` array
+- `{Child}/{GrandChild}`: match all descendant members of `Child`, all types are children of `GrandChild`
+
+The member name and type can be mixed on the path (currently it is not supported to specify the member name and type at the same time in the same level path)
+
+- `child/{GrandChild}`: match all descendant members whose name is `child`, all types are child members of `GrandChild`
+- `{Child}/grandChild/content`: match all descendant members whose type is `Child`, the child members named `grandChild`, and the child members named `content`
+
+**3. Use subscripts to access array members**
+
+Use square brackets with numerical values to indicate that the matching position is an array type, and the object with the specified subscript is taken (without subscript, when the matching object is an array type, all objects in the array are matched)
+
+- `children[1]/content`: match the descendant members of the array type named `children`, and take the child member named `content` in the `2`th object
+- `parent/children[1]`: match the child member of the array type named `children` among the descendant members named `parent`, and take the `2`th object among them
+
+**4. Use wildcards**
+
+Wildcards can be used to match member names or type names
+
+- `child*`: match all descendant members whose name starts with `child`
+- `{*Child}`: match all descendant members whose type ends with `Child`
+- `c*ld/{Grand*ld}`: match the descendant members whose name starts with `c` and ends with `ld`, and the members whose type starts with `Grand` and ends with `ld`
+- `child/*/content`: At this time, `*` will match any member, that is, the child member of `content` contained in any child member of the `child` object
+
+For details, see the use cases in the test classes of the `java-demo` and `kotlin-demo` sample projects `DemoOmniMethodsTest`.
+
+### 3. Special instructions
+
+> **Do you really need to use `OmniAccessor`? **
+>
+> `OmniAccessor` implement the basic anti-refactoring mechanism based on the Fail-Fast principle. When the access path provided by the user cannot match any member, the `OmniAccessor` will immediately throw a `NoSuchMemberError` error, so that the unit test is terminated early. However, compared to the conventional member access method, the support of `OmniAccessor` in IDE refactoring is still weak.
+>
+> For content assignment of complex objects, in most cases, we recommend using [Builder Pattern](https://www.geeksforgeeks.org/builder-pattern-in-java/), or exposing Getter/Setter method implementations. Although these conventional methods are slightly clumsy (especially when you need to assign values to many similar members in batches), they are more friendly to the encapsulation and reconstruction of business logic.
+> Only when the original type is not suitable for transformation, and there is no other way to access the target member, `OmniAccessor` is the last resort.

docs/en-us/doc/parameter-constructor.md

@@ -1,6 +0,0 @@
-Parameter constructor
----
-
-No matter how intricate the parameter structure required by the method under test is, even there is no suitable construction method, or even there are private internal class objects... Call `TestableMock`, the parameter object will be handed to you immediately~
-
-This feature is planned to be released in the `0.5.x` version.

docs/en-us/doc/private-accessor.md

@@ -9,26 +9,42 @@ In addition, before unit testing begin, it is often necessary to initialize spec
 
 Just add `@EnablePrivateAccess` annotation to the test class, then you have got the following enhancements in the test case:
 
-- Invoke private methods (including static methods) of the class under test
-- Read private fields (including static fields) of the class under test
-- Modify private fields (including static fields) of the class under test
-- Modify the constant fields of the class under test (fields modified with final, including static fields)
+- Invoke private methods (including static methods) of the **class under test**
+- Read private fields (including static fields) of the **class under test**
+- Modify private fields (including static fields) of the **class under test**
+- Modify the constant fields of the **class under test** (fields modified with final, including static fields)
 
 When accessing and modifying private and constant members, the IDE may prompt some syntax errors, but the compiler will be able to run the test normally.
 
 For the effect, see the use case in the test class of the `java-demo` sample project `DemoPrivateAccessTest`. (Using compile-time code enhancement, currently only the adaptation of the Java language is implemented)
 
+> This function assumes that the test class is in the same package as the class under test, and the name is `<ClassUnderTest>+Test`. When this convention is not met, you can use the `srcClass` parameter on the `@EnablePrivateAccess` annotation to specify the actual class under test. E.g:
+>
+> ```java
+> @EnablePrivateAccess(srcClass = DemoServiceImpl.class)
+> class DemoServiceTest() { ... }
+> ```
+
 ### Solution 2: Use the `PrivateAccessor` tool class
 
 If you don't want to see the IDE's syntax error reminder, or in a non-Java language JVM project (such as Kotlin language), you can also use the `PrivateAccessor` tool class to directly access private members.
 
-This class provides 6 static methods:
+This class provides 7 static methods:
 
-- `PrivateAccessor.get(<ObjectUnderTest>, "<private-field-name>")` ➜ read the private field of the class under test
-- `PrivateAccessor.set(<ObjectUnderTest>, "<private-field-name>", <new-value>)` ➜ modify the private field (or constant field) of the class under test
-- `PrivateAccessor.invoke(<ObjectUnderTest>, "<private-method-name>", <call-parameters>..)` ➜ call the private method of the class under test
-- `PrivateAccessor.getStatic(<ClassUnderTest>, "<private-static-field-name>")` ➜ read the **static** private field of the class under test
-- `PrivateAccessor.setStatic(<ClassUnderTest>, "<private-static-field-name>", <new-value>)` ➜ modify the **static** private field (or **static** constant field) of the class under test
-- `PrivateAccessor.invokeStatic(<ClassUnderTest>, "<private-static-method-name>", <call-parameters>..)` ➜ call the **static** private method of the class under test
+- `PrivateAccessor.get(<AnyObject>, "<private-field-name>")` ➜ read the private field of any object
+- `PrivateAccessor.set(<AnyObject>, "<private-field-name>", <new-value>)` ➜ modify the private field (or constant field) of any object
+- `PrivateAccessor.invoke(<AnyObject>, "<private-method-name>", <call-parameters>...)` ➜ call the private method of any object
+- `PrivateAccessor.getStatic(<AnyClass>, "<private-static-field-name>")` ➜ read the **static** private field of any class
+- `PrivateAccessor.setStatic(<AnyClass>, "<private-static-field-name>", <new-value>)` ➜ modify the **static** private field (or **static** constant field) of any class
+- `PrivateAccessor.invokeStatic(<AnyClass>, "<private-static-method-name>", <call-parameters>...)` ➜ call the **static** private method of any class
+- `PrivateAccessor.construct(<AnyClass>, <constructor-parameters>...)` ➜ create a new object by the private constructor of any class
+
+> Using the `PrivateAccessor` class does not require the test class to have `@EnablePrivateAccess` annotation, but adding this annotation will enable the compile-time verification for the private members of the class under test.
 
 For details, see the use cases in the test classes of the `java-demo` and `kotlin-demo` sample projects `DemoPrivateAccessTest`.
+
+### Compile-time verification of private members
+
+Both of the above two methods essentially use JVM reflection mechanism to achieve private member access, but the JVM compiler will not check the existence of the reflection target. When the code is refactored, if the private method names and parameters in the source class are modified, it would cause exceptions to be discovered only when the unit test is triggered. For this reason, another function of the `@EnablePrivateAccess` annotation is to perform additional compile-time checks for existence of private member of the **class under test**.
+
+**Note**: When the private member verification function is enabled, the `PrivateAccessor` class can only be used to access the private members of the **class under test**, which will help limit the using of the `PrivateAccessor` tool class for "unauthorized" operations unrelated to the current test. If you really need to access private members of other classes, you can remove the `@EnablePrivateAccess` annotation, or set the `verifyTargetOnCompile` parameter of the annotation to `false` to manually turn off the verification function.

docs/en-us/doc/release-note.md

@@ -1,5 +1,55 @@
 # Release Note
 
+## 0.6.5
+- fix an issue cause `OmniConstructor` fail to handle classes like Date and BigDecimal
+- fix an issue of `PrivateAccessor` fail to invoke method with single array parameter
+- fix an issue of mock methods in super class are ignored when `scope` is `associated`
+- fix an issue of empty mock method not works when `scope` is `associated`
+
+## 0.6.4
+- `TestableNull` class removed, let `OmniConstructor` even lighter
+- support `@Nested` annotation of JUnit 5
+- fix several `OmniConstructor` compatibility issues（thanks to [@ddatsh](https://github.com/ddatsh)）
+
+## 0.6.3
+- support custom inner `Mock` class name
+- support skip specified packages from `OmniConstructor` enhancement
+- fix 2 circle construction cases in `OmniConstructor`
+- fix an index out-of-range issue caused by non-static method without `this` reference
+- fix a null pointer exception caused by resource folder unavailable at runtime
+
+## 0.6.2
+- support setup global testable agent configure via properties file
+- disable OmniConstructor bytecode enhancement by default
+- fix a `Spring` framework compatibility issue with OmniConstructor
+
+## 0.6.1
+- generate mock scanning log file automatically, for self-troubleshooting
+- fix a `Spock` test framework compatibility issue
+- fix a `Gradle` unit test runtime compatibility issue
+
+## 0.6.0
+- add `OmniConstructor` and `OmniAccessor` tool for parameter preparation
+- fix a `ClassFormatError` caused by incorrect `FRAME FULL` operation
+- remove support for`diagnose` parameter of `@MockWith` annotation
+
+## 0.5.2
+- support use`PrivateAccessor` to access private member in parent class
+- fix a class format error in jvm 1.8+ cause by incorrect bytecode generation
+- fix illegal field modifiers error when add mock class to an interface
+
+## 0.5.1
+- use kotlin-style method descriptor in `VERBOSE` diagnose logs
+- support parameterized test of JUnit 5
+- fix an exception caused by method parameter with ternary operator
+- fix a bug cause log message lost when `@MockWith` annotation used
+
+## 0.4.12
+- support verbose diagnose log for better self-troubleshooting
+- support disable private access target existence check
+- support specify mock scanning packages
+- fix an ArrayIndexOutOfBoundsException issue when transforming native method
+
 ## 0.4.11
 - support accessing private members of class under test in different package path 
 - validate the number of private method parameters accessed by `PrivateAccessor`

docs/en-us/doc/scope-of-mock.md

@@ -0,0 +1,4 @@
+Effective Scope Of Mocking
+---
+
+TO BE TRANSLATED

docs/en-us/doc/setup.md

@@ -1,12 +1,12 @@
 Use TestableMock
 ---
 
-`TestableMock` is an assist tool for Java unit testing based on source code and bytecode enhancement, including the following functions:
+`TestableMock` is now not only a lightweight and easy-to-use unit testing mock tool, but also a comprehensive set of auxiliary tools aimed at **simplifying Java unit testing**, including the following functions:
 
 - [Quickly mock arbitrary call](en-us/doc/use-mock.md): quickly replace any method invocation in the class under test with a mock method, solve the cumbersome use of traditional mock tools problem
 - [Access private members of the class under test](en-us/doc/private-accessor.md): enable unit tests directly invoke or access private members of the class under test, solve the problems of private member initialization and private method testing
+- [Quickly construct complicated parameter object](en-us/doc/omni-constructor.md)：generate arbitrarily nested object instances, simplify their internal member assignment methods, solve the problem of long initialization codes for method parameters
 - [Auxiliary test void method](en-us/doc/test-void-method.md): use the mock validator to check the internal logic of method, solve the problem that unit testing is difficult to implement to the method with no return value
-- [Quickly construct complicated parameter object](en-us/doc/parameter-constructor.md)：generate arbitrarily nested object instances, simplify their internal member assignment methods, solve the problem of long initialization codes for method parameters
 
 ## Use in Maven project
 
@@ -16,7 +16,7 @@ It is recommended to add a `property` field that identifies the TestableMock ver
 
 ```xml
 <properties>
-    <testable.version>0.4.11</testable.version>
+    <testable.version>0.6.5</testable.version>
 </properties>
 ```
 
@@ -63,8 +63,8 @@ Add dependence of `TestableMock` in `build.gradle` file:
 
 ```groovy
 dependencies {
-    testImplementation('com.alibaba.testable:testable-all:0.4.11')
-    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.4.11')
+    testImplementation('com.alibaba.testable:testable-all:0.6.5')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.5')
 }
 ```
 
@@ -93,3 +93,20 @@ See the [build.gradle](https://github.com/alibaba/testable-mock/blob/master/demo
 > ```
 >
 > See [issue-43](https://github.com/alibaba/testable-mock/issues/43) for a complete example.
+
+> If the project is using `Spock` test framework, you need to specify the bytecode version generated by `Groovy` to be 1.6 or above, the method is as follows (please modify the properties value according to the actual JVM version used).
+>
+> For Maven project, add `<maven.compiler.source>` and `<maven.compiler.target>` properties inside the `pom.xml` file, e.g.
+> ```xml
+> <properties>
+>   <maven.compiler.source>1.6</maven.compiler.source>
+>   <maven.compiler.target>1.6</maven.compiler.target>
+> </properties>
+> ```
+>
+> For Gradle project, add a `sourceCompatibility` property inside the `build.gradle` file, e.g.
+> ```groovy
+> sourceCompatibility = '6'
+> ```
+>
+> See project `demo/spock-demo` for a complete example.

docs/en-us/doc/test-void-method.md

@@ -76,11 +76,13 @@ After executing the void type method under test, use `InvokeVerifier.verify()` t
 class DemoTest {
     private Demo demo = new Demo();
 
-    // Intercept `System.out.println` invocation
-    @MockMethod
-    public void println(PrintStream ps, String msg) {
-        // Execute the original call
-        ps.println(msg);
+    public static class Mock {
+        // Intercept `System.out.println` invocation
+        @MockMethod
+        public void println(PrintStream ps, String msg) {
+            // Execute the original call
+            ps.println(msg);
+        }
     }
 
     @Test

docs/en-us/doc/troubleshooting.md

@@ -3,44 +3,89 @@ Self-Help Troubleshooting
 
 Compared with `Mockito` and other mock tools where developers have to manually inject mock classes, `TestableMock` uses method name and parameter type matching to automatically find invocations that require mock. While this mechanism brings convenience, it may also cause unexpected mock replacement.
 
-To troubleshoot mock-related issues, just add the `@MockWith` annotation to the test class, and configure the parameter `diagnose` to `MockDiagnose.ENABLE`, so the detailed mock method replacement process will be printed when the test is run.
+For this reason, `TestableMock` will automatically save the mock scanning log of the last test run in the project build directory. The default location is `target/testable-agent.log` (Maven project) or `build/testable-agent.log` (Gradle project).
 
-```java
-@MockWith(diagnose = MockDiagnose.ENABLE)
-class DemoTest {
-    ...
-}
-```
-
-The output log example is as follows:
+Examples of log content are as follows:
 
 ```text
-[DIAGNOSE] Handling test class com/alibaba/testable/demo/DemoMockTest
-[DIAGNOSE] Handling source class com/alibaba/testable/demo/DemoMock
-[DIAGNOSE]   Found 7 mock methods
-[DIAGNOSE]   Handling method <init>
-[DIAGNOSE]   Handling method newFunc
-[DIAGNOSE]     Line 14, mock method createBlackBox used
-[DIAGNOSE]   Handling method outerFunc
-[DIAGNOSE]     Line 22, mock method innerFunc used
-[DIAGNOSE]   Handling method commonFunc
-[DIAGNOSE]     Line 29, mock method trim used
-[DIAGNOSE]     Line 29, mock method sub used
-[DIAGNOSE]     Line 29, mock method startsWith used
-[DIAGNOSE]   Handling method getBox
-[DIAGNOSE]     Line 36, mock method secretBox used
-[DIAGNOSE]   Handling method callerOne
-[DIAGNOSE]     Line 43, mock method callFromDifferentMethod used
-[DIAGNOSE]   Handling method callerTwo
-[DIAGNOSE]     Line 47, mock method callFromDifferentMethod used
-[DIAGNOSE]   Handling method innerFunc
-[DIAGNOSE]   Handling method callFromDifferentMethod
+[INFO] Start at Mon Jan 00 00:00:00 CST 0000
+... ...
+[INFO] Found test class com/alibaba/testable/demo/basic/DemoMockTest
+[INFO]   Found 6 test cases
+[INFO] Found mock class com/alibaba/testable/demo/basic/DemoMockTest$Mock
+[INFO]   Found 8 mock methods
+[INFO] Found source class com/alibaba/testable/demo/basic/DemoMock
+[INFO]   Found method <init>
+[INFO]   Found method newFunc
+[INFO]     Line 19, mock method "createBlackBox" used
+[INFO]   Found method outerFunc
+[INFO]     Line 27, mock method "innerFunc" used
+[INFO]     Line 27, mock method "staticFunc" used
+[INFO]   Found method commonFunc
+[INFO]     Line 34, mock method "trim" used
+[INFO]     Line 34, mock method "sub" used
+[INFO]     Line 34, mock method "startsWith" used
+... ...
+[INFO] Completed at Mon Jan 00 00:00:00 CST 0000
 ```
 
 The log shows all the mocked invocation and corresponding code line numbers in the class under test.
 
-- Self troubleshooting:
+According to the targeted test classes, below are some simple clues for self-troubleshooting. Suppose the class under test is "com.demo.BizService", the test class is "com.demo.BizServiceTest", and the mock container class is "com.demo.BizServiceTest.Mock":
 
-- If there is no output, please check whether the `pom.xml` or `build.gradle` configuration correctly introduces `TestableMock` dependencies
-- If only the first line of `Handling test class` is output, please check whether the test class is in the same package of the class under test, and the name is "<ClassUnderTest>+Test" (required for `0.4.x` version)
-- If `Handling source class` and `Handling method xxx` are output, but there is no mock replacement happen at the expected code line, please check whether the mock method definition matches the target method
+- If the log file is no generated, please check whether the `pom.xml` or `build.gradle` configuration correctly introduces `TestableMock` dependencies
+- If only `com/demo/BizServiceTest$Mock` is found in the output, please check whether the mock class is created at correct place
+- If both the test class and the mock class are found, but the class under test `com/demo/BizService` not appeared, please check whether the test class is in the same package of the class under test, and the name is "<ClassUnderTest>+Test", otherwise `@MockWith` annotation should be used
+- If all the three classes are found, and `Found method xxx` are output, but there is no mock replacement happen at the expected code line, please check whether the mock method definition matches the target method
+
+For situations where expected mocking is not take effect, you could add a `@MockDiagnose` annotation to the mock class, and set the diagnosis level to `LogLevel.VERBOSE` for further investigation information.
+
+```java
+class BizServiceTest {
+    @MockDiagnose(LogLevel.VERBOSE)
+    public static class Mock {
+        ...
+    }
+}
+```
+
+Executing the unit test again will print out the signatures of all mock methods, and the signatures of all invocations scanned in the class under test:
+
+```text
+[INFO] Found test class com/alibaba/testable/demo/basic/DemoMockTest
+[TIP]    Test case "should_mock_new_object"
+... ...
+[TIP]    Test case "should_set_mock_context"
+[INFO]   Found 6 test cases
+[INFO] Found mock class com/alibaba/testable/demo/basic/DemoMockTest$Mock
+[TIP]    Mock constructor "createBlackBox" as "com.alibaba.demo.basic.model.mock.BlackBox(java.lang.String)"
+[TIP]    Mock method "innerFunc" as "com.alibaba.demo.basic.DemoMock::innerFunc(java.lang.String) : java.lang.String"
+... ...
+[TIP]    Mock method "callFromDifferentMethod" as "()Ljava/lang/String;"
+[INFO]   Found 8 mock methods
+[INFO] Found source class com/alibaba/testable/demo/basic/DemoMock
+[INFO]   Found method <init>
+[TIP]      Line 13, constructing "java.lang.Object()"
+[INFO]   Found method newFunc
+[TIP]      Line 19, constructing "com.alibaba.demo.basic.model.mock.BlackBox(java.lang.String)"
+[INFO]     Line 19, mock method "createBlackBox" used
+[TIP]      Line 19, invoking "com.alibaba.demo.basic.DemoMockTest$Mock::createBlackBox(java.lang.String) : com.alibaba.demo.basic.model.mock.BlackBox"
+[TIP]      Line 20, invoking "com.alibaba.demo.basic.model.mock.BlackBox::get() : java.lang.String"
+[INFO]   Found method outerFunc
+[TIP]      Line 27, constructing "java.lang.StringBuilder()"
+[TIP]      Line 27, invoking "java.lang.StringBuilder::append(java.lang.String) : java.lang.StringBuilder"
+[TIP]      Line 27, invoking "com.alibaba.demo.basic.DemoMock::innerFunc(java.lang.String) : java.lang.String"
+[INFO]     Line 27, mock method "innerFunc" used
+... ...
+```
+
+The logs are formatted in follow pattern:
+
+- `Mock constructor "<MockMethodName>" as "<Signature>" for "<TypeName>"` Mock constructor found in test class
+- `Mock method "<MockMethodName>" as "<Signature>"` Mock method found in test class (the first parameter that identify the mock target class is currently kept)
+- `Line XX, constructing "<TypeName>" as "<Signature>"` Constructor invocation found in test under class
+- `Line XX, invoking "<MethodName>" as "<Signature>"` Member method invocation found in test under class
+
+> In order to clearly distinguish between the type of method return value and the type of invoker, the method signature recorded in the log uses a method definition structure similar to `Kotlin`.
+
+Comparing the actual signature of the original call with the signature defined by the mock method, the problem is usually found quickly.