release v0.6.4

* 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.4')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.4')
 }
 
 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.4</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/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/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.4")
+    testAnnotationProcessor("com.alibaba.testable:testable-processor:0.6.4")
 }
 
 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.4</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/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/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.4')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.4')
+}
+
+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.4</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,49 @@
 # Release Note
 
+## 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.4</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.4')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.4')
 }
 ```
 
@@ -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.

docs/en-us/doc/upgrade-guide.md

@@ -0,0 +1,67 @@
+Upgrade Guide
+---
+
+### Upgrade to v0.6
+
+In version `0.6`，`TestableMock` provided a new [quick complicated class construction](en-us/doc/omni-constructor.md) capability. Meanwhile, it includes a modification that is incompatible with the `0.5` version: class `PrivateAccessor` have been moved from `com.alibaba.testable.core.accessor` package to `com.alibaba.testable.core.tool` package.
+
+If you are using `PrivateAccessor` and having import statement like this:
+
+```java
+import com.alibaba.testable.core.accessor.PrivateAccessor;
+```
+
+When upgrade `TestableMock` to `0.6` version, please replace it as：
+
+```java
+import com.alibaba.testable.core.tool.PrivateAccessor;
+```
+
+### Upgrade to v0.5
+
+The `0.5` version solves the three historical problems left over before:
+
+1. <s>**Mock method cannot call other non-static methods**</s>. The mock method in the new version no longer has any difference from the ordinary method, and can access any external method and member variable.
+2. <s>**Mock method always acts on the entire test life cycle**</s>. From now on, the mock method supports restricting the effective scope to the test cases in the test class of which it belongs, so there is no need to worry about accidentally mocking cross-class test invocations.
+3. <s>**The MOCK_CONTEXT needs manually cleaned up and only supports class-level parallel testing**</s>. Now each test case has an independent `MOCK_CONTEXT` variable, no need to clean up after used, and you can use unit test with any parallel level.
+
+In order to better realize the reuse of Mock methods, the version `0.5` have made a clear boundary between the mock class and the test class in the new version. When upgrading from `0.4` to `0.5`, the only change required is to wrap all mock methods in the test class with a `public static class Mock {}`.
+
+For example, the original test class definition was as follows:
+
+```java
+public class DemoMockTest {
+    @MockMethod(targetClass = DemoMock.class)
+    private String innerFunc(String text) {
+        return "hello_" + text;
+    }
+        
+    @Test
+    void should_mock_member_method() throws Exception {
+        assertEquals("hello_world", demoMock.outerFunc());
+        verify("innerFunc").with("world");
+    }
+}
+```
+
+After upgrading to the `0.5` version, move all mock methods (in this example, only the `innerFunc` method) to a static inner class named `Mock`, which is equivalent to adding two lines of code:
+
+```java
+public class DemoMockTest {
+
+    public static class Mock {   // Add this line
+        @MockMethod(targetClass = DemoMock.class)
+        private String innerFunc(String text) {
+            return "hello_" + text;
+        }
+    }                            // Add this line
+        
+    @Test
+    void should_mock_member_method() throws Exception {
+        assertEquals("hello_world", demoMock.outerFunc());
+        verify("innerFunc").with("world");
+    }
+}
+```
+
+Finally, upgrade the `TestableMock` dependency in `pom.xml` or `build.gradle` file to the new version.

docs/en-us/doc/use-mock-with.md

@@ -0,0 +1,4 @@
+Use MockWith Annotation
+---
+
+TO BE TRANSLATED

docs/en-us/doc/use-mock.md

@@ -1,21 +1,37 @@
 Fast Mocking
 ---
 
-Compared with the class-granularity mocking practices of existing mock tools, `TestableMock` allows developers to directly define a single method and use it for mocking. With the principle of convention over configuration, mock method replacement will automatically happen when the specified method in the test class match an invocation in the class under test.
+In unit testing, the main role of the mock method is to replace those methods with **need external dependencies**, **with time-consuming**, **has random results**, or other effects that affect the development of the test, but do not affect the key the logic to be tested. Generally speaking, a certain call needs to be mocked, which is usually only related to its own characteristics, and has nothing to do with the source of the invocation.
+
+Based on the above information, `TestableMock` has designed a minimalist mock mechanism. Unlike the common mock tools that uses **class** as the definition granularity of mocking, and repeats the description of mock behavior in each test case, `TestableMock` allows each business class (class under test) to be associated with a set of reusable collection of mock methods (carried by the mock container class), following the principle of "convention over configuration", and mock method replacement will automatically happen when the specified method in the test class match an invocation in the class under test.
 
 > In summary, there are two simple rules:
-> - Mock non-constructive method, copy the original method definition to the test class, add a `@MockMethod` annotation
-> - Mock construction method, copy the original method definition to the test class, replace the return value with the constructed type, the method name is arbitrary, and add a `@MockContructor` annotation
+> - Mock non-constructive method, copy the original method definition to the mock class, add a `@MockMethod` annotation
+> - Mock construction method, copy the original method definition to the mock class, replace the return value with the constructed type, the method name is arbitrary, and add a `@MockContructor` annotation
 
-The detail mock method definition convention is as follows:
+The detail mock method definition convention is as follows.
 
-#### 1. Mock method calls of any class
+### 0. Pre-step, prepare the mock class
 
-Define an ordinary method annotated with `@MockMethod` in the test class with exactly the same signature (name, parameter, and return value type) as the method to be mocked, and then add the type of target object (which the method originally belongs to) as `targetMethod` parameter of `@MockMethod` annotation.
+First, create a mock class as the container for mock methods associated with the test class. The simplest way is to add a static inner class named `Mock` to the test class. E.g:
+
+```java
+public class DemoTest {
+
+    public static class Mock {
+        // mock methods goes here
+    }
+
+}
+```
+
+### 1.1 Mock method calls of any class
+
+Define an ordinary method annotated with `@MockMethod` in the mock class with exactly the same signature (name, parameter, and return value type) as the method to be mocked, and then add the type of target object (which the method originally belongs to) as `targetMethod` parameter of `@MockMethod` annotation.
 
 At this time, all invocations to that original method in the class under test will be automatically replaced with invocations to the above-mentioned mock method when the unit test is running.
 
-For example, there is a call to `"anything".substring(1, 2)` in the class under test, and we want to change it to a fixed string when running the test, we only need to define the following method in the test class:
+For example, there is a call to `"anything".substring(1, 2)` in the class under test, and we want to change it to a fixed string when running the test, we only need to define the following method in the mock class:
 
 ```java
 // The original method signature is `String substring(int, int)`
@@ -41,7 +57,7 @@ private String use_any_mock_method_name(int i, int j) {
 
 Sometimes, the mock method need to access the member variables in the original object that initiated the invocation, or invoke other methods of the original object. At this point, you can remove the `targetClass` parameter in the `@MockMethod` annotation, and then add a extra parameter whose type is the original object type of the method to the first index of the method parameter list.
 
-The `TestableMock` convention is that when the `targetClass` parameter value of the `@MockMethod` annotation is empty, the first parameter of the mock method is the type of the target method, and the parameter name is arbitrary. In order to facilitate code reading, it is recommended to name this parameter as `self` or `src`. Example as follows:
+The `TestableMock` convention is that when the `targetClass` parameter of the `@MockMethod` annotation is not defined, the first parameter of the mock method is the type of the target method, and the parameter name is arbitrary. In order to facilitate code reading, it is recommended to name this parameter as `self` or `src`. Example as follows:
 
 ```java
 // Adds a `String` type parameter to the first position the mock method parameter list (parameter name is arbitrary)
@@ -53,15 +69,15 @@ private String substring(String self, int i, int j) {
 }
 ```
 
-For complete code examples, see the `should_able_to_mock_common_method()` test cases in the `java-demo` and `kotlin-demo` sample projects. (Because Kotlin has made magical changes to the String type, the method under test in the Kotlin example adds a layer of encapsulation to the `BlackBox` class)
+For complete code examples, see the `should_mock_common_method()` test cases in the `java-demo` and `kotlin-demo` sample projects. (Because `Kotlin` has made magical changes to the String type, the method under test in the `Kotlin` example adds a layer of encapsulation to the `BlackBox` class)
 
-#### 2. Mock the member method of the class under test itself
+### 1.2 Mock the member method of the class under test itself
 
 Sometimes, when testing certain methods, it is desirable to mock out some other member methods of the class under test itself.
 
 The solution is the same as the previous case. Just set `targetClass` parameter value to the type of class under test.
 
-For example, there is a private method with the signature `String innerFunc(String)` in the class under test. If we want to replace it during testing, we only need to define the following method in the test class:
+For example, there is a private method with the signature `String innerFunc(String)` in the class under test. If we want to replace it during testing, we only need to define the following method in the mock class:
 
 ```java
 // The type to test is `DemoMock`
@@ -73,9 +89,9 @@ private String innerFunc(String text) {
 
 Similarly, if the method in the above example needs to access the original tested object that initiated the call, it may not use the `targetClass` parameter, but when defining the mock method, add a parameter of type `DemoMock` to the first index of the method parameter list.
 
-For complete code examples, see the `should_able_to_mock_member_method()` test case in the `java-demo` and `kotlin-demo` sample projects.
+For complete code examples, see the `should_mock_member_method()` test case in the `java-demo` and `kotlin-demo` sample projects.
 
-#### 3. Mock static methods of any class
+### 1.3 Mock static methods of any class
 
 Mock for static methods is the same as for any ordinary methods.
 
@@ -88,11 +104,11 @@ private BlackBox secretBox() {
 }
 ```
 
-For complete code examples, see the `should_able_to_mock_static_method()` test case in the `java-demo` and `kotlin-demo` sample projects.
+For complete code examples, see the `should_mock_static_method()` test case in the `java-demo` and `kotlin-demo` sample projects.
 
-#### 4. Mock `new` operation of any type
+### 1.4 Mock `new` operation of any type
 
-Define an ordinary method annotated with `@MockContructor` in the test class, make the return value type of the method the type of the object to be created, and the method parameters are exactly the same as the constructor parameters to be mocked, the method name is arbitrary.
+Define an ordinary method annotated with `@MockContructor` in the mock class, make the return value type of the method the type of the object to be created, and the method parameters are exactly the same as the constructor parameters to be mocked, the method name is arbitrary.
 
 At this time, all operations in the class under test that use `new` to create the specified class (and use the constructor that is consistent with the mock method parameters) will be replaced with calls to the custom method.
 
@@ -109,9 +125,9 @@ private BlackBox createBlackBox(String text) {
 
 > You can still use the `@MockMethod` annotation, and configure the `targetMethod` parameter value to `"<init>"`, and the rest is the same as above. The effect is the same as using the `@MockContructor` annotation
 
-For complete code examples, see the `should_able_to_mock_new_object()` test case in the `java-demo` and `kotlin-demo` sample projects.
+For complete code examples, see the `should_mock_new_object()` test case in the `java-demo` and `kotlin-demo` sample projects.
 
-#### 5. Identify the current test case and invoke source
+### 2. Identify different invocation source in mock method
 
 In the mock method, you can use the `TestableTool.SOURCE_METHOD` variable to identify **the method name of the class under test before entering the mock method**; in addition, the `TestableTool.MOCK_CONTEXT` variable can **inject additional context parameters into the mock method**, to distinguish and process different calling scenarios.
 
@@ -124,7 +140,6 @@ public void testDemo() {
     assertEquals(true, demo());
     MOCK_CONTEXT.set("case", "has-error");
     assertEquals(false, demo());
-    MOCK_CONTEXT.clear();
 }
 ```
 
@@ -144,24 +159,21 @@ private Data mockDemo() {
 }
 ```
 
-Note that because `TestableMock` does not (and won't to) rely on any specific test framework, it cannot automatically identify the end position of a single test case, which makes the parameters set to the `TestableTool.MOCK_CONTEXT` variable may exist cross test cases in the same test class. It is recommended to always use `MOCK_CONTEXT.clear()` to clear the context immediately after use. You can also add this statement to the unified position where the test case ends of the specific unit test framework, such as the `@AfterEach` method of JUnit 5.
+For complete code examples, see the `should_get_source_method_name()` and `should_get_test_case_name()` test cases in the `java-demo` and `kotlin-demo` sample projects.
 
-In the current version, the effect of this variable at runtime is similar to a normal `Map` type member object in the test class, but please try to use this variable instead of a custom object to pass additional mock parameters in order to get better compatibility in the upcoming`v0.5` version.
+### 3. Verify the sequence and parameters of the mock method being invoked
 
-> The `TestableTool.MOCK_CONTEXT` variable is currently shared within the test class. When the unit test runs in parallel, it is recommended to select the `parallel` type as `classes`
-
-For complete code examples, see the `should_able_to_get_source_method_name()` and `should_able_to_get_test_case_name()` test cases in the `java-demo` and `kotlin-demo` sample projects.
-
-#### 6. Verify the sequence and parameters of the mock method being invoked
-
-In test cases, you can use the `TestableTool.verify()` method, and cooperate with `with()`, `withInOrder()`, `without()`, `withTimes()` and other methods to verify the mock call situation.
+In test cases, you can use the `InvokeVerifier.verify()` method, and cooperate with `with()`, `withInOrder()`, `without()`, `withTimes()` and other methods to verify the mock call situation.
 
 For details, please refer to the [Check Mock Call](en-us/doc/matcher.md) document.
 
-#### Additional note
+### 4. Special instructions
 
-> **Mock convention in version 0.4.x**:
-> - The name of the test class must be `<NameOfClassUnderTest> + Test` (and in the same package path), which is usually the by-default naming convention of Java project managed by `Maven` or `Gradle`.
-> - Do NOT access any non-`static` members in mock methods. Currently, methods that is decorated by `@MockMethod` or `@MockContructor` annotations will be automatically modified to `static` methods during runtime. (When mock method contains some statement like _lambda function_, _anonymous class_ or _initiation block_, java compiler will generate additional method during compilation, these mock methods also have to be declared as `static` to avoid non-static dynamical method invoked.)
+> **Naming Conventions for Test Classes and Mock Containers**
 >
-> These constraints will change in `0.5` versions of `TestableMock`.
+> By default, `TestableMock` assumes that the <u>package path of the test class and the class under test are the same, and the name is `<ClassUnderTest>+Test`</u> (usually Java project with `Maven` or `Gradle` conform to this convention).
+> At the same time, it is agreed that the mock container associated with the test class is <u>in its internal static class named `Mock`</u>, or <u>an independent class named `<ClassUnderTest>+Mock` under the same package path</u>.
+>
+> When the test class or mock container path does not follow to this convention, you can use the `@MockWith` annotation to specify it explicitly. For details, see [Use MockWith Annotation](en-us/doc/use-mock-with.md).
+
+For more implementation details of `TestableMock`, please refer to the [Design and Principle](en-us/doc/design-and-mechanism.md) document.

docs/en-us/sidebar.md

@@ -2,17 +2,24 @@
   - [Use TestableMock](en-us/doc/setup.md)
   - [Fast Mocking](en-us/doc/use-mock.md)
   - [Private Accessor](en-us/doc/private-accessor.md)
+  - [Omni Constructor](en-us/doc/omni-constructor.md)
   - [Test Void Method](en-us/doc/test-void-method.md)
-  - [Parameter constructor](en-us/doc/parameter-constructor.md)
 
 - Usage Guide
   - [Verify Mock Invocation](en-us/doc/invoke-matcher.md)
+  - [Effective Scope Of Mocking](zh-cn/doc/scope-of-mock.md)
+  - [Reusing Mock Methods](zh-cn/doc/mock-method-reusing.md)
+  - [Use MockWith Annotation](zh-cn/doc/use-mock-with.md)
   - [Frequently Asked Questions](en-us/doc/frequently-asked-questions.md)
   - [Use TestableMock In IDE](en-us/doc/use-in-ide.md)
   - [Self-Help Troubleshooting](en-us/doc/troubleshooting.md)
   - [Testable Maven Plugin](en-us/doc/use-maven-plugin.md)
 
 - Technical Reference
+  - [Upgrade Guide](en-us/doc/upgrade-guide.md)
+  - [Available Global Arguments](zh-cn/doc/javaagent-args.md)
+  - [Available Annotations](zh-cn/doc/annotations.md)
+  - [How Mock Works](zh-cn/doc/design-and-mechanism.md)
   - [Mock Tools Comparison](en-us/doc/comparation.md)
   - [Release Note](en-us/doc/release-note.md)
   - [About Us](en-us/doc/about-us.md)

docs/zh-cn/README.md

@@ -5,7 +5,7 @@ TestableMock简介
 
 在定义Mock方法时，开发者真正关心的只有一件事："<u>这个调用，在测试的时候要换成那个假的Mock方法</u>"。
 
-然而当下主流的Mock框架在实现Mock功能时，需要开发者操心的事情实在太多：Mock框架如何初始化、与所用的单元测试框架是否兼容、要被Mock的方法是不是私有的、是不是静态的、被Mock对象是new出来的还是注入的、怎样把被测对象送回被测类里...这些非关键的额外工作极大分散了使用Mock工具应有的乐趣。
+当下主流的Mock框架在实现Mock功能时，需要开发者操心的事情实在太多：Mock框架如何初始化、与所用的服务框架是否兼容、要被Mock的方法是不是私有的、是不是静态的、被Mock对象是new出来的还是注入的、怎样把被测对象送回被测类里...这些非关键的额外工作极大分散了使用Mock工具应有的乐趣。
 
 于是，我们开发了`TestableMock`，**一款特立独行的轻量Mock工具**。
 

docs/zh-cn/doc/annotations.md

@@ -0,0 +1,60 @@
+注解参数清单
+---
+
+基于轻量的原则，`TestableMock`为开发者提供了尽可能精炼、易用的注解组合，以下参数信息可供开发参考。
+
+#### @EnablePrivateAccess
+
+启用对被测类的<u>私有成员访问编译期增强</u>和<u>私有目标存在性的编译期校验</u>功能。
+
+- 作用于：测试类
+
+| 参数                   | 类型    | 是否必须 | 默认值 | 作用 |
+| ---                   | ---     | ---     | ---- | ---  |
+| srcClass              | Class   | 否      | N/A   | 当测试类命名不符合约定时，指定实际被测类 |
+| verifyTargetOnCompile | boolean | 否      | true  | 是否启用私有目标的编译期存在性校验 |
+
+#### @MockMethod
+
+将当前方法标识为待匹配的Mock成员方法。
+
+- 作用于：Mock容器类中的方法
+
+| 参数          | 类型       | 是否必须 | 默认值           | 作用 |
+| ---          | ---       | ---     | ----             | ---  |
+| targetClass  | Class     | 否      | N/A              | 指定Mock目标的调用者类型 |
+| targetMethod | String    | 否      | N/A              | 指定Mock目标的方法名 |
+| scope        | MockScope | 否      | MockScope.GLOBAL | 指定Mock的生效范围 |
+
+#### @MockConstructor
+
+将当前方法标识为待匹配的Mock构造方法。
+
+- 作用于：Mock容器类中的方法
+
+| 参数   | 类型      | 是否必须 | 默认值            | 作用 |
+| ---   | ---       | ---    | ----             | ---  |
+| scope | MockScope | 否      | MockScope.GLOBAL | 指定Mock的生效范围 |
+
+
+#### @MockWith
+
+显式指定当前类型关联的Mock容器类。
+
+- 作用于：测试类、被测类
+
+| 参数（`N/A`为默认参数） | 类型       | 是否必须 | 默认值                 | 作用 |
+| ---                  | ---       | ---     | ----                  | ---  |
+| N/A                  | Class     | 否      | NullType.class        | 指定使用的Mock容器类 |
+| treatAs              | ClassType | 否      | ClassType.GuessByName | 指定当前类是测试类或被测类 | 
+
+#### @MockDiagnose
+
+启用或禁止Mock相关的诊断信息输出。
+
+- 作用于：Mock容器类
+
+| 参数（`N/A`为默认参数） | 类型      | 是否必须 | 默认值 | 作用 |
+| ---                  | ---      | ---     | ----  | ---  |
+| N/A                  | LogLevel | 是      | N/A   | 指定当前Mock容器关联测试用例的诊断日志级别 |
+

docs/zh-cn/doc/comparation.md

@@ -21,6 +21,6 @@
 
 相比之下，`TestabledMock`的功能与`PowerMock`基本平齐，且极易上手，只需掌握`@MockMethod`注解就可以完成绝大多数任务。
 
-当前`TestableMock`的主要不足在于，编写Mock方法时IDE尚无法即时提示方法参数是否正确匹配。若发现匹配效果不符合预期，需要通过[自助问题排查](zh-cn/doc/troubleshooting.md)文档提供的方法在运行期进行校验。这个功能未来需要通过扩展主流IDE插件来提供。
+当前`TestableMock`的主要不足在于，编写Mock方法时IDE无法即时提示方法参数是否正确匹配。若发现匹配效果不符合预期，需要通过[自助问题排查](zh-cn/doc/troubleshooting.md)文档提供的方法在运行期进行校验。这个功能理论上能够通过扩展主流IDE插件来补充，但目前暂无相关开发计划，参见[Issue-104](https://github.com/alibaba/testable-mock/issues/104)。
 
-此外，由于`TestableMock`独辟蹊径的采用基于单个方法的Mock机制，将Mock方法定义与单元测试用例解耦，一方面使得Mock方法具有默认可复用性，单元测试用例也因此变得更干净纯粹，另一方面也导致Mock方法定义变得零散，生命周期管理起来相对困难，对现有开发者的Mock编写习惯会带来一定改变。
+此外，由于`TestableMock`独辟蹊径的采用“每个业务类拥有一个专属Mock容器类”的思维方式，将Mock方法定义与单元测试用例解耦，一方面使得Mock方法具有默认可复用性，单元测试用例也因此变得更干净纯粹，另一方面也导致Mock方法定义变得零散，生命周期管理起来相对困难，对现有开发者的Mock编写习惯会带来一定改变。

docs/zh-cn/doc/design-and-mechanism.md

@@ -0,0 +1,29 @@
+TestableMock的设计和原理
+---
+
+这篇文档主要介绍`TestableMock`中Mock功能的设计思想和实现原理。
+
+与常见的Mock工具在每个测试用例里写Mock定义不同，`TestableMock`让每个业务类直接提供自己的Mock方法集合，描述自身在测试时需要被Mock的调用以及相应替代逻辑（即每个业务类有自己的独立Test类和独立Mock类）。采用约定优于配置，降低Mock学习理解成本、减少冗余信息。
+
+这种设计基于两项基本假设：
+
+1. 同一个测试类里，一个测试用例里需要Mock掉的方法，在其他测试用例里通常也都需要Mock。因为这些被Mock的方法往往访问了不便于测试的外部依赖。
+2. 每个单元测试只关注被测单元内部的逻辑，单元外的无关调用应该被替换为Mock。即需要被Mock的调用应该都在被测类的代码中。
+
+据此通过约定来简化符合以上假设的单元测试场景，通过配置来支持其余更复杂的使用场景。
+
+`TestableMock`的原理可以用一句话概括：<u>利用JavaAgent动态修改字节码，把被测的业务类中与所有与Mock方法定义匹配的调用在单元测试运行时替换成对Mock方法的调用</u>。
+
+最终达到的效果则是，不论代码用什么服务框架、什么对象容器，不论要Mock的目标对象是注入的、new出来的、全局的还是局部的，不论要Mock的目标方法是私有的、外部的、静态的、继承来的或者重载过的，全部无差别通吃，让单元测试回归简单。
+
+> 划重点：Mock的目标是**被测类**中的**方法调用**。测试用例里的代码不会被Mock，方法的定义本身没有变化，只是发起调用的代码被替换了。
+
+具体来说，在单元测试启动时，`TestableMock`会对加载到内存中的类进行预处理，同时分别建立“被测类”、“测试类”、“Mock容器类”之间的关联关系（可以是一对一，也可以是多对一）。这个关联一方面是为了在测试用例执行时能够正确匹配Mock调用并进行替换，另一方面则是为了能控制Mock方法的生效范围。
+
+对于被测类，将匹配到的调用换成对Mock容器方法的调用。
+
+对于测试类，在每个测试用例开头插入Mock上下文初始化代码。
+
+对于Mock容器类，增加`testableIns()`方法变成单例类，在每个Mock方法开头插入记录调用的代码。
+
+以上是整个Mock的核心逻辑，更多实现细节，请参考源码。若有任何问题、建议、改进提议，都欢迎通过Github Issue和Pull Request参与讨论、贡献😃