release v0.6

* master:
  update faq about how to mock inner class

.gitignore

@@ -1,10 +1,10 @@
 # maven ignore
 target/
-*.jar
-*.war
-*.zip
-*.tar
-*.tar.gz
+
+# gradle ignore
+build/
+out/
+.gradle/
 
 # eclipse ignore
 .settings/
@@ -34,3 +34,8 @@ Thumbs.db
 
 # others
 note/
+*.jar
+*.war
+*.zip
+*.tar
+*.tar.gz

README.md

@@ -2,17 +2,36 @@
 
 换种思路写Mock，让单元测试更简单。
 
-无需初始化，不挑测试框架，甭管要换的方法是被测类的私有方法、静态方法还是其他任何类的成员方法，也甭管要换的对象是怎么创建的。写好Mock方法，加个`@TestableMock`注解，一切统统搞定。
+无需初始化，不挑服务框架，甭管要换的是私有方法、静态方法、构造方法还是其他任何类的任何方法，也甭管要换的对象是怎么创建的。写好Mock定义，加个`@MockMethod`注解，一切统统搞定。
 
-文档：https://alibaba.github.io/testable-mock/
+- 文档：https://alibaba.github.io/testable-mock/
+- 国内文档镜像：http://freyrlin.gitee.io/testable-mock/
+
+阅读[这里](https://mp.weixin.qq.com/s/KyU6Eu7mDkZU8FspfSqfMw)了解更多故事。
+
+<font size="5">**0.6版本已发布**</font>，从`0.5.x`升级到`0.6.x`版本请参考[版本升级指南](https://alibaba.github.io/testable-mock/#/zh-cn/doc/upgrade-guide)
+
+如果有遇到其他任何使用问题和建议，请直接在[Issue](https://github.com/alibaba/testable-mock/issues)中提出，也可通过[Pull Request](https://github.com/alibaba/testable-mock/pulls)提交您的代码，我们将在24小时内回复并处理
+
+-----
+
+## 版本计划
+
+`TestableMock`正在持续迭代演进，以下版本计划可能在开发过程中发生调整
+
+- `0.6` 当前版本，进行中的工作内容参考[Issue](https://github.com/alibaba/testable-mock/issues)清单
+- `0.7` 完善Mock功能的防代码重构机制，支持快速Mock指定类型的所有方法
+- `1.0` 功能稳定，一个崭新的开始
 
 ## 目录结构
 
 ```bash
-|-- testable-core         ➜ 核心组件，提供注解和工具类
-|-- testable-processor    ➜ 编译期代码预处理组件，提供测试辅助功能
-|-- testable-agent        ➜ JavaAgent组件，提供Mock测试相关功能
-|-- testable-maven-plugin ➜ Maven插件组件，用于简化JavaAgent注入
+|-- testable-parent       ➜ 提供各子模块的公共父pom文件
+|-- testable-all          ➜ 依赖聚合，便于一次性引用所有子模块功能
+|-- testable-processor    ➜ 编译期代码预处理模块，提供测试辅助功能
+|-- testable-agent        ➜ JavaAgent模块，提供Mock测试相关功能
+|-- testable-core         ➜ 基础功能模块，提供Mock相关注解和工具类
+|-- testable-maven-plugin ➜ Maven插件模块，用于简化JavaAgent注入
 |-- demo
 |   |-- java-demo         ➜ Java语言的示例代码
 |   `-- kotlin-demo       ➜ Kotlin语言的示例代码
@@ -33,5 +52,5 @@ mvn clean install
 docsify serve docs
 ```
 
-> Testable文档使用`docsify`工具生成，构建前请安装[nodejs](https://nodejs.org/en/download/)运行时，并使用`npm install -g docsify`命令安装文档生成工具。
+> TestableMock文档使用`docsify`工具生成，构建前请安装[nodejs](https://nodejs.org/en/download/)运行时，并使用`npm install -g docsify`命令安装文档生成工具。
 

README_EN.md

@@ -0,0 +1,47 @@
+# TestableMock
+
+Write mock faster, make unit testing easier.
+
+Any test framework, no initialization, no matter private method, static method, construction method, or any other method of any class, and no matter how the object created.
+Write a mock method, add an `@MockMethod` annotation, everything is done.
+
+Usage Document: https://alibaba.github.io/testable-mock/#/en-us/
+
+## Roadmap
+
+`TestableMock` is still under heavy development, the following version plans may be adjusted during the iteration
+
+- `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
+
+```bash
+|-- testable-parent       ➜ Provide parent pom file shared by other modules
+|-- testable-all          ➜ Dependence aggration, for easily import all modules at once
+|-- testable-processor    ➜ Compile-time code preprocessing module, provides test assist functions
+|-- 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
+|-- demo
+|   |-- java-demo         ➜ Java code example
+|   `-- kotlin-demo       ➜ Kotlin code example
+`-- docs                  ➜ Source code of usage document
+```
+
+## Build project
+
+The project is built using JDK 1.6+ and Maven 3+, except for the `demo` sub-project requires JDK 1.8+.
+
+```bash
+mvn clean install
+```
+
+## Generate document
+
+```bash
+docsify serve docs
+```
+
+> `TestableMock` document is generated by `docsify` tool, please install [nodejs](https://nodejs.org/en/download/) before execution, and run `npm install -g docsify` command to install the tool required.

demo/java-demo/build.gradle

@@ -0,0 +1,27 @@
+plugins {
+    id 'java'
+}
+
+group = 'com.alibaba.testable'
+version = '1.0.0-SNAPSHOT'
+sourceCompatibility = '8'
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation('org.junit.jupiter:junit-jupiter:5.6.2')
+    testImplementation('com.alibaba.testable:testable-all:0.6.0')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.0')
+}
+
+tasks.withType(JavaCompile) {
+    options.encoding = "UTF-8"
+}
+
+test {
+    jvmArgs "-javaagent:${classpath.find { it.name.contains("testable-agent") }.absolutePath}"
+    useJUnitPlatform()
+}

demo/java-demo/pom.xml

@@ -11,20 +11,21 @@
     <properties>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
-        <testable.version>0.3.1</testable.version>
+        <junit.version>5.6.2</junit.version>
+        <testable.version>0.6.0</testable.version>
     </properties>
 
     <dependencies>
         <dependency>
             <groupId>com.alibaba.testable</groupId>
-            <artifactId>testable-processor</artifactId>
+            <artifactId>testable-all</artifactId>
             <version>${testable.version}</version>
-            <scope>provided</scope>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.6.2</version>
+            <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
@@ -35,14 +36,10 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>3.0.0-M5</version>
+                <configuration>
+                    <argLine>@{argLine} -javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>
+                </configuration>
             </plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<configuration>
-					<argLine>@{argLine} -javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>
-				</configuration>
-			</plugin>
 <!--            <plugin>-->
 <!--                <groupId>com.alibaba.testable</groupId>-->
 <!--                <artifactId>testable-maven-plugin</artifactId>-->

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

@@ -1,11 +1,12 @@
-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;
 
 /**
- * @author flin
+ * 演示父类变量引用子类对象时的Mock场景
+ * Demonstrate scenario of mocking method from sub-type object referred by parent-type variable
  */
 public class DemoInherit {
 

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;
@@ -9,7 +9,8 @@ import java.util.HashSet;
 import java.util.List;
 
 /**
- * @author flin
+ * 演示Mock方法调用校验器
+ * Demonstrate mock method invocation verifier
  */
 public class DemoMatcher {
 

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

@@ -1,10 +1,15 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
-import com.alibaba.testable.demo.model.BlackBox;
-import sun.net.www.http.HttpClient;
+import com.alibaba.demo.basic.model.mock.BlackBox;
 
-import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.stream.Collectors;
 
+/**
+ * 演示基本的Mock功能
+ * Demonstrate basic mock functionality
+ */
 public class DemoMock {
 
     /**
@@ -19,7 +24,7 @@ public class DemoMock {
      * method with member method invoke
      */
     public String outerFunc(String s) throws Exception {
-        return "{ \"res\": \"" + innerFunc(s) + "\"}";
+        return "{ \"res\": \"" + innerFunc(s) + staticFunc() + "\"}";
     }
 
     /**
@@ -47,8 +52,12 @@ public class DemoMock {
         return callFromDifferentMethod();
     }
 
+    private static String staticFunc() {
+        return "_STATIC_TAIL";
+    }
+
     private String innerFunc(String s) throws Exception {
-        return HttpClient.New(new URL("http:/xxx/" + s)).getURLFile();
+        return Files.readAllLines(Paths.get("/a-not-exist-file")).stream().collect(Collectors.joining());
     }
 
     private String callFromDifferentMethod() {

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

@@ -0,0 +1,52 @@
+package com.alibaba.demo.basic;
+
+import java.util.List;
+
+/**
+ * 演示私有成员访问功能
+ * Demonstrate private member access functionality
+ */
+public class DemoPrivateAccess {
+
+    /**
+     * a private static field
+     */
+    private static int staticCount;
+    /**
+     * a private member field
+     */
+    private int count;
+    /**
+     * a constant field
+     */
+    public final Double pi = 3.14;
+
+    /**
+     * private static method without arguments
+     */
+    private static String privateStaticFunc() {
+        return "static";
+    }
+
+    /**
+     * private static method with arguments
+     */
+    private static String privateStaticFuncWithArgs(String str, int i) {
+        return (str == null ? "null" : str) + " + " + i;
+    }
+
+    /**
+     * private member method without arguments
+     */
+    private String privateFunc() {
+        return "member";
+    }
+
+    /**
+     * private member method with arguments
+     */
+    private String privateFuncWithArgs(List<String> list, String str, int i) {
+        return list.stream().reduce((a, s) -> a + s).orElse("") + " + " + str + " + " + i;
+    }
+
+}

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

@@ -0,0 +1,39 @@
+package com.alibaba.demo.basic;
+
+import java.util.*;
+
+/**
+ * 演示模板方法的Mock场景
+ * Demonstrate scenario of mocking template method
+ */
+public class DemoTemplate {
+
+    private <T> List<T> getList(T value) {
+        List<T> l = new ArrayList<>();
+        l.add(value);
+        return l;
+    }
+
+    private <K, V> Map<K, V> getMap(K key, V value) {
+        Map<K, V> m = new HashMap<>();
+        m.put(key, value);
+        return m;
+    }
+
+    public String singleTemplateMethod() {
+        List<String> list = getList("demo");
+        return list.get(0);
+    }
+
+    public String doubleTemplateMethod() {
+        Map<String, String> map = getMap("hello", "testable");
+        return map.get("hello");
+    }
+
+    public Set<?> newTemplateMethod() {
+        Set<String> set = new HashSet<>();
+        set.add("world");
+        return set;
+    }
+
+}

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/main/java/com/alibaba/testable/demo/DemoPrivateAccess.java

@@ -1,27 +0,0 @@
-package com.alibaba.testable.demo;
-
-/**
- * @author flin
- */
-public class DemoPrivateAccess {
-
-    private int count;
-
-    public final Double pi = 3.14;
-
-    /**
-     * private method
-     */
-    private String privateFunc(String s, int i) {
-        return s + " - " + i;
-    }
-
-    /**
-     * method with private field access
-     */
-    public String privateFieldAccessFunc() {
-        count += 2;
-        return String.valueOf(count);
-    }
-
-}

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,26 +1,32 @@
-package com.alibaba.testable.demo;
+package com.alibaba.demo.basic;
 
-import com.alibaba.testable.core.annotation.TestableMock;
+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.jupiter.api.Test;
 
 import static com.alibaba.testable.core.matcher.InvokeMatcher.*;
 import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
 import static org.junit.jupiter.api.Assertions.fail;
 
+/**
+ * 演示Mock方法调用校验器
+ * Demonstrate mock method invocation verifier
+ */
 class DemoMatcherTest {
 
     private DemoMatcher demoMatcher = new DemoMatcher();
 
-    @TestableMock(targetMethod = "methodToBeMocked")
-    private void methodWithoutArgument(DemoMatcher self) {}
+    public static class Mock {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithoutArgument(DemoMatcher self) {}
 
-    @TestableMock(targetMethod = "methodToBeMocked")
-    private void methodWithArguments(DemoMatcher self, Object a1, Object a2) {}
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithArguments(DemoMatcher self, Object a1, Object a2) {}
 
-    @TestableMock(targetMethod = "methodToBeMocked")
-    private void methodWithArrayArgument(DemoMatcher self, Object[] a) {}
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithArrayArgument(DemoMatcher self, Object[] a) {}
+    }
 
     @Test
     void should_match_no_argument() {

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,88 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.annotation.TestableMock;
-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.Test;
-
-import static com.alibaba.testable.core.matcher.InvokeVerifier.verify;
-import static org.junit.jupiter.api.Assertions.*;
-
-class DemoInheritTest {
-
-    @TestableMock(targetMethod = "put")
-    private void put_into_box(Box self, String something) {
-        self.put("put_" + something + "_into_box");
-    }
-
-    @TestableMock(targetMethod = "put")
-    private void put_into_blackbox(BlackBox self, String something) {
-        self.put("put_" + something + "_into_blackbox");
-    }
-
-    @TestableMock(targetMethod = "get")
-    private String get_from_box(Box self) {
-        return "get_from_box";
-    }
-
-    @TestableMock(targetMethod = "get")
-    private String get_from_blackbox(BlackBox self) {
-        return "get_from_blackbox";
-    }
-
-    @TestableMock(targetMethod = "getColor")
-    private String get_color_from_color(Color self) {
-        return "color_from_color";
-    }
-
-    @TestableMock(targetMethod = "getColor")
-    private String get_color_from_blackbox(BlackBox self) {
-        return "color_from_blackbox";
-    }
-
-    private DemoInherit demoInherit = new DemoInherit();
-
-    @Test
-    void should_able_to_mock_call_sub_object_method_by_parent_object() throws Exception {
-        BlackBox box = (BlackBox)demoInherit.putIntoBox();
-        verify("put_into_box").withTimes(1);
-        assertEquals("put_data_into_box", box.get());
-    }
-
-    @Test
-    void should_able_to_mock_call_sub_object_method_by_sub_object() throws Exception {
-        BlackBox box = demoInherit.putIntoBlackBox();
-        verify("put_into_blackbox").withTimes(1);
-        assertEquals("put_data_into_blackbox", box.get());
-    }
-
-    @Test
-    void should_able_to_mock_call_parent_object_method_by_parent_object() throws Exception {
-        String content = demoInherit.getFromBox();
-        verify("get_from_box").withTimes(1);
-        assertEquals("get_from_box", content);
-    }
-
-    @Test
-    void should_able_to_mock_call_parent_object_method_by_sub_object() throws Exception {
-        String content = demoInherit.getFromBlackBox();
-        verify("get_from_blackbox").withTimes(1);
-        assertEquals("get_from_blackbox", content);
-    }
-
-    @Test
-    void should_able_to_mock_call_interface_method_by_interface_object() throws Exception {
-        String color = demoInherit.getColorViaColor();
-        verify("get_color_from_color").withTimes(1);
-        assertEquals("color_from_color", color);
-    }
-
-    @Test
-    void should_able_to_mock_call_interface_method_by_sub_class_object() throws Exception {
-        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,103 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.annotation.TestableMock;
-import com.alibaba.testable.demo.model.BlackBox;
-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.*;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-class DemoMockTest {
-
-    @TestableMock(targetMethod = CONSTRUCTOR)
-    private BlackBox createBlackBox(String text) {
-        return new BlackBox("mock_" + text);
-    }
-
-    @TestableMock
-    private String innerFunc(DemoMock self, String text) {
-        return "mock_" + text;
-    }
-
-    @TestableMock
-    private String trim(String self) {
-        return "trim_string";
-    }
-
-    @TestableMock(targetMethod = "substring")
-    private String sub(String self, int i, int j) {
-        return "sub_string";
-    }
-
-    @TestableMock
-    private boolean startsWith(String self, String s) {
-        return false;
-    }
-
-    @TestableMock
-    private BlackBox secretBox(BlackBox ignore) {
-        return new BlackBox("not_secret_box");
-    }
-
-    @TestableMock
-    private String callFromDifferentMethod(DemoMock self) {
-        if (TEST_CASE.equals("should_able_to_get_test_case_name")) {
-            return "mock_special";
-        }
-        switch (SOURCE_METHOD) {
-            case "callerOne": return "mock_one";
-            default: return "mock_others";
-        }
-    }
-
-    private DemoMock demoMock = new DemoMock();
-
-    @Test
-    void should_able_to_mock_new_object() throws Exception {
-        assertEquals("mock_something", demoMock.newFunc());
-        verify("createBlackBox").with("something");
-    }
-
-    @Test
-    void should_able_to_mock_member_method() throws Exception {
-        assertEquals("{ \"res\": \"mock_hello\"}", demoMock.outerFunc("hello"));
-        verify("innerFunc").with("hello");
-    }
-
-    @Test
-    void should_able_to_mock_common_method() throws Exception {
-        assertEquals("trim_string__sub_string__false", demoMock.commonFunc());
-        verify("trim").withTimes(1);
-        verify("sub").withTimes(1);
-        verify("startsWith").withTimes(1);
-    }
-
-    @Test
-    void should_able_to_mock_static_method() throws Exception {
-        assertEquals("not_secret_box", demoMock.getBox().get());
-        verify("secretBox").withTimes(1);
-    }
-
-    @Test
-    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
-    void should_able_to_get_test_case_name() throws Exception {
-        // 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/testable/demo/DemoPrivateAccessTest.java

@@ -1,37 +0,0 @@
-package com.alibaba.testable.demo;
-
-import com.alibaba.testable.core.accessor.PrivateAccessor;
-import com.alibaba.testable.processor.annotation.EnablePrivateAccess;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-@EnablePrivateAccess
-class DemoPrivateAccessTest {
-
-    private DemoPrivateAccess demoPrivateAccess = new DemoPrivateAccess();
-
-    @Test
-    void should_able_to_access_private_method() throws Exception {
-        assertEquals("hello - 1", demoPrivateAccess.privateFunc("hello", 1));
-        assertEquals("hello - 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc", "hello", 1));
-    }
-
-    @Test
-    void should_able_to_access_private_field() throws Exception {
-        demoPrivateAccess.count = 2;
-        assertEquals("4", demoPrivateAccess.privateFieldAccessFunc());
-        assertEquals(new Integer(4), demoPrivateAccess.count);
-
-        PrivateAccessor.set(demoPrivateAccess, "count", 3);
-        assertEquals("5", demoPrivateAccess.privateFieldAccessFunc());
-        assertEquals(new Integer(5), PrivateAccessor.get(demoPrivateAccess, "count"));
-    }
-
-    @Test
-    void should_able_to_update_final_field() throws Exception {
-        demoPrivateAccess.pi = 4.13;
-        assertEquals(4.13, demoPrivateAccess.pi);
-    }
-
-}

demo/kotlin-demo/build.gradle.kts

@@ -0,0 +1,33 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm") version "1.4.10"
+}
+
+group = "com.alibaba.testable"
+version = "1.0.0-SNAPSHOT"
+java.sourceCompatibility = JavaVersion.VERSION_1_8
+
+repositories {
+    mavenCentral()
+}
+
+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.6.0")
+    testAnnotationProcessor("com.alibaba.testable:testable-processor:0.6.0")
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions {
+        freeCompilerArgs = listOf("-Xjsr305=strict")
+        jvmTarget = "1.8"
+    }
+}
+
+tasks.withType<Test> {
+    jvmArgs("-javaagent:${classpath.find { it.name.contains("testable-agent") }!!.absolutePath}")
+    useJUnitPlatform()
+}

demo/kotlin-demo/pom.xml

@@ -1,122 +1,119 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <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>kotlin-demo</artifactId>
-	<version>1.0.0-SNAPSHOT</version>
-	<name>kotlin-demo</name>
-	<description>Demo project for TestableMock</description>
+    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>kotlin-demo</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <name>kotlin-demo</name>
+    <description>Demo project for TestableMock</description>
 
-	<properties>
-		<java.version>1.8</java.version>
-		<kotlin.version>1.3.72</kotlin.version>
-		<maven.compiler.source>1.8</maven.compiler.source>
-		<maven.compiler.target>1.8</maven.compiler.target>
-		<testable.version>0.3.1</testable.version>
-	</properties>
+    <properties>
+        <java.version>1.8</java.version>
+        <kotlin.version>1.3.72</kotlin.version>
+        <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.6.0</testable.version>
+    </properties>
 
-	<dependencies>
-		<dependency>
-			<groupId>org.jetbrains.kotlin</groupId>
-			<artifactId>kotlin-reflect</artifactId>
-			<version>${kotlin.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>org.jetbrains.kotlin</groupId>
-			<artifactId>kotlin-stdlib-jdk8</artifactId>
-			<version>${kotlin.version}</version>
-		</dependency>
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-reflect</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib-jdk8</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
 
-		<dependency>
-			<groupId>com.alibaba.testable</groupId>
-			<artifactId>testable-processor</artifactId>
-			<version>${testable.version}</version>
-			<scope>provided</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
-			<version>5.6.2</version>
-			<scope>test</scope>
-		</dependency>
-	</dependencies>
+        <dependency>
+            <groupId>com.alibaba.testable</groupId>
+            <artifactId>testable-all</artifactId>
+            <version>${testable.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
-	<build>
-		<sourceDirectory>src/main/kotlin</sourceDirectory>
-		<testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0-M5</version>
-			</plugin>
-<!--			<plugin>-->
-<!--				<groupId>org.apache.maven.plugins</groupId>-->
-<!--				<artifactId>maven-surefire-plugin</artifactId>-->
-<!--				<configuration>-->
-<!--					<argLine>@{argLine} -javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>-->
-<!--				</configuration>-->
-<!--			</plugin>-->
-			<plugin>
-				<groupId>com.alibaba.testable</groupId>
-				<artifactId>testable-maven-plugin</artifactId>
-				<version>${testable.version}</version>
-				<executions>
-					<execution>
-						<id>prepare</id>
-						<goals>
-							<goal>prepare</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-			<plugin>
-				<groupId>org.jacoco</groupId>
-				<artifactId>jacoco-maven-plugin</artifactId>
-				<version>0.8.6</version>
-				<executions>
-					<execution>
-						<id>prepare-agent</id>
-						<goals>
-							<goal>prepare-agent</goal>
-						</goals>
-					</execution>
-					<execution>
-						<id>report</id>
-						<phase>prepare-package</phase>
-						<goals>
-							<goal>report</goal>
-						</goals>
-						<configuration>
-							<dataFile>target/jacoco.exec</dataFile>
-							<outputDirectory>target/jacoco-ut</outputDirectory>
-						</configuration>
-					</execution>
-				</executions>
-			</plugin>
-			<plugin>
-				<groupId>org.jetbrains.kotlin</groupId>
-				<artifactId>kotlin-maven-plugin</artifactId>
-				<version>${kotlin.version}</version>
-				<executions>
-					<execution>
-						<id>compile</id>
-						<phase>compile</phase>
-						<goals>
-							<goal>compile</goal>
-						</goals>
-					</execution>
-					<execution>
-						<id>test-compile</id>
-						<phase>test-compile</phase>
-						<goals>
-							<goal>test-compile</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-		</plugins>
-	</build>
+    <build>
+        <sourceDirectory>src/main/kotlin</sourceDirectory>
+        <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.0.0-M5</version>
+<!--                <configuration>-->
+<!--                    <argLine>@{argLine} -javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>-->
+<!--                </configuration>-->
+            </plugin>
+            <plugin>
+                <groupId>com.alibaba.testable</groupId>
+                <artifactId>testable-maven-plugin</artifactId>
+                <version>${testable.version}</version>
+                <executions>
+                    <execution>
+                        <id>prepare</id>
+                        <goals>
+                            <goal>prepare</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.6</version>
+                <executions>
+                    <execution>
+                        <id>prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>report</id>
+                        <phase>prepare-package</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                        <configuration>
+                            <dataFile>target/jacoco.exec</dataFile>
+                            <outputDirectory>target/jacoco-ut</outputDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-maven-plugin</artifactId>
+                <version>${kotlin.version}</version>
+                <executions>
+                    <execution>
+                        <id>compile</id>
+                        <phase>compile</phase>
+                        <goals>
+                            <goal>compile</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>test-compile</id>
+                        <phase>test-compile</phase>
+                        <goals>
+                            <goal>test-compile</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
 
 </project>

demo/kotlin-demo/settings.gradle.kts

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

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

@@ -1,9 +1,13 @@
-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场景
+ * Demonstrate scenario of mocking method from sub-type object referred by parent-type variable
+ */
 class DemoInherit {
 
     /**

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,10 +1,11 @@
-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.*
 
 /**
- * @author flin
+ * 演示Mock方法调用校验器
+ * Demonstrate mock method invocation verifier
  */
 class DemoMatcher {
     /**
@@ -41,8 +42,24 @@ class DemoMatcher {
         val longArray = arrayOf(1L, 2L)
         methodToBeMocked(1, 2)
         methodToBeMocked(1L, 2.0)
+
+        // below two invocations are equivalent
         methodToBeMocked(listOf(1), setOf(1.0f))
+        // multiple lines method invocation
+        methodToBeMocked(object : ArrayList<Int?>() {
+            init {
+                add(1)
+            }
+        }, object : HashSet<Float?>() {
+            init {
+                add(1.0f)
+            }
+        })
+
+        // below two invocations are equivalent
         methodToBeMocked(1.0, mapOf(1 to 1.0f))
+        methodToBeMocked(1.0, object : HashMap<Int?, Float?>(2) { init { put(1, 1.0f) } })
+
         methodToBeMocked(floatList, floatList)
         methodToBeMocked(longArray)
         methodToBeMocked(arrayOf(1.0, 2.0))

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

@@ -1,10 +1,14 @@
-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 sun.net.www.http.HttpClient
-import java.net.URL
+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
 
+/**
+ * 演示基本的Mock功能
+ * Demonstrate basic mock functionality
+ */
 class DemoMock {
 
     /**
@@ -18,7 +22,7 @@ class DemoMock {
      * method with member method invoke
      */
     fun outerFunc(s: String): String {
-        return "{ \"res\": \"" + innerFunc(s) + "\"}"
+        return "{ \"res\": \"" + innerFunc(s) + staticFunc() + "\"}"
     }
 
     /**
@@ -47,7 +51,19 @@ class DemoMock {
         return callFromDifferentMethod()
     }
 
-    private fun innerFunc(s: String) = HttpClient.New(URL("http:/xxx/$s")).urlFile
+    private fun innerFunc(s: String): String {
+        return Files.readAllLines(Paths.get("/a-not-exist-file")).joinToString()
+    }
 
     private fun callFromDifferentMethod() = "realOne"
+
+    companion object {
+        private fun staticFunc(): String {
+            return "_STATIC_TAIL"
+        }
+
+//        fun callStaticFunc(): String {
+//            return "CALL${staticFunc()}"
+//        }
+    }
 }

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

@@ -0,0 +1,48 @@
+package com.alibaba.demo.basic
+
+/**
+ * 演示私有成员访问功能
+ * Demonstrate private member access functionality
+ */
+class DemoPrivateAccess {
+
+    /**
+     * a private member field
+     */
+    var count = 0
+
+    /**
+     * a constant field
+     */
+    val pi = 3.14
+
+    /**
+     * private member method
+     */
+    fun privateFunc(list: List<String>, str: String, i: Int): String {
+        return list.reduce { a: String, s: String -> a + s } + " + " + "$str + $i"
+    }
+
+    companion object {
+
+        /**
+         * a private static field
+         */
+        var staticCount = 0
+
+        /**
+         * private static method
+         */
+        fun privateStaticFunc(str: String, i: Int): String {
+            return "$str + $i"
+        }
+
+        /**
+         * private jvm static method
+         */
+        @JvmStatic private fun privateJvmStaticFunc(list: List<String>, str: String, i: Int): String {
+            return list.reduce { a: String, s: String -> a + s } + " * " + "$str * $i"
+        }
+    }
+
+}

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

@@ -0,0 +1,39 @@
+package com.alibaba.demo.basic
+
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.HashSet
+
+/**
+ * 演示模板方法的Mock场景
+ * Demonstrate scenario of mocking template method
+ */
+class DemoTemplate {
+    private fun <T> getList(value: T): List<T> {
+        val l: MutableList<T> = ArrayList()
+        l.add(value)
+        return l
+    }
+
+    private fun <K, V> getMap(key: K, value: V): Map<K, V> {
+        val m: MutableMap<K, V> = HashMap()
+        m[key] = value
+        return m
+    }
+
+    fun singleTemplateMethod(): String {
+        val list = getList("demo")
+        return list[0]
+    }
+
+    fun doubleTemplateMethod(): String? {
+        val map = getMap("hello", "testable")
+        return map["hello"]
+    }
+
+    fun newTemplateMethod(): Set<*> {
+        val set: MutableSet<String> = HashSet()
+        set.add("world")
+        return set
+    }
+}

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/PathUtil.kt

@@ -1,4 +1,4 @@
-package com.alibaba.testable.demo.util
+package com.alibaba.demo.java2kotlin
 
 import java.io.File
 import java.io.IOException

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/main/kotlin/com/alibaba/testable/demo/DemoPrivateAccess.kt

@@ -1,24 +0,0 @@
-package com.alibaba.testable.demo
-
-class DemoPrivateAccess {
-
-    private var count = 0
-
-    final val pi = 3.14
-
-    /**
-     * private method
-     */
-    private fun privateFunc(s: String, i: Int): String {
-        return "$s - $i"
-    }
-
-    /**
-     * method with private field access
-     */
-    fun privateFieldAccessFunc(): String {
-        count += 2
-        return count.toString()
-    }
-
-}

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,29 +1,34 @@
-package com.alibaba.testable.demo
+package com.alibaba.demo.basic
 
-import com.alibaba.testable.core.annotation.TestableMock
+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
 
-
+/**
+ * 演示Mock方法调用校验器
+ * Demonstrate mock method invocation verifier
+ */
 internal class DemoMatcherTest {
 
-    @TestableMock(targetMethod = "methodToBeMocked")
-    private fun methodWithoutArgument(self: DemoMatcher) {
-    }
+    private val demoMatcher = com.alibaba.demo.basic.DemoMatcher()
 
-    @TestableMock(targetMethod = "methodToBeMocked")
-    private fun methodWithArguments(self: DemoMatcher, a1: Any, a2: Any) {
-    }
+    class Mock {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithoutArgument(self: com.alibaba.demo.basic.DemoMatcher) {
+        }
 
-    @TestableMock(targetMethod = "methodToBeMocked")
-    private fun methodWithArrayArgument(self: DemoMatcher, a: Array<Any>) {
-    }
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithArguments(self: com.alibaba.demo.basic.DemoMatcher, a1: Any, a2: Any) {
+        }
 
-    private val demoMatcher = DemoMatcher()
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithArrayArgument(self: com.alibaba.demo.basic.DemoMatcher, a: Array<Any>) {
+        }
+    }
 
     @Test
     fun should_match_no_argument() {
@@ -40,8 +45,8 @@ internal class DemoMatcherTest {
         InvokeVerifier.verify("methodWithArguments").withInOrder(InvokeMatcher.anyInt(), 2)
         InvokeVerifier.verify("methodWithArguments").withInOrder(InvokeMatcher.anyLong(), InvokeMatcher.anyNumber())
         // Note: Must use `::class.javaObjectType` for primary types check in Kotlin
-        InvokeVerifier.verify("methodWithArguments").with(1.0, InvokeMatcher.anyMapOf(Int::class.javaObjectType, Float::class.javaObjectType))
-        InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyList(), InvokeMatcher.anySetOf(Float::class.javaObjectType))
+        InvokeVerifier.verify("methodWithArguments").with(1.0, InvokeMatcher.anyMapOf(Int::class.javaObjectType, Float::class.javaObjectType)).times(2)
+        InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyList(), InvokeMatcher.anySetOf(Float::class.javaObjectType)).times(2)
         InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyList(), InvokeMatcher.anyListOf(Float::class.javaObjectType))
         InvokeVerifier.verify("methodWithArrayArgument").with(InvokeMatcher.anyArrayOf(Long::class.javaObjectType))
         InvokeVerifier.verify("methodWithArrayArgument").with(InvokeMatcher.anyArray())
@@ -66,12 +71,12 @@ internal class DemoMatcherTest {
     @Test
     fun should_match_with_times() {
         demoMatcher.callMethodWithNumberArguments()
-        InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyNumber(), InvokeMatcher.any()).times(3)
+        InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyNumber(), InvokeMatcher.any()).times(4)
 
         demoMatcher.callMethodWithNumberArguments()
         var gotError = false
         try {
-            InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyNumber(), InvokeMatcher.any()).times(4)
+            InvokeVerifier.verify("methodWithArguments").with(InvokeMatcher.anyNumber(), InvokeMatcher.any()).times(5)
         } catch (e: VerifyFailedError) {
             gotError = true
         }

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

@@ -0,0 +1,123 @@
+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.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
+
+/**
+ * 演示基本的Mock功能
+ * Demonstrate basic mock functionality
+ */
+internal class DemoMockTest {
+
+    private val demoMock = DemoMock()
+
+    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 staticFunc(): String {
+            return "_MOCK_TAIL";
+        }
+
+        @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)
+        private fun startsWith(s: String) = false
+
+        @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 = 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_mock_new_object() {
+        assertEquals("mock_something", demoMock.newFunc())
+        verify("createBlackBox").with("something")
+    }
+
+    @Test
+    fun should_mock_member_method() {
+        assertEquals("{ \"res\": \"mock_hello_MOCK_TAIL\"}", demoMock.outerFunc("hello"))
+        verify("innerFunc").with("hello")
+        verify("staticFunc").with()
+    }
+
+//    @Test
+//    fun should_mock_method_in_companion_object() {
+//        assertEquals("CALL_MOCK_TAIL", DemoMock.callStaticFunc())
+//        verify("staticFunc").with()
+//    }
+
+    @Test
+    fun 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
+    fun should_mock_static_method() {
+        assertEquals("White_not_secret_box", demoMock.getBox().get())
+        verify("secretBox").withTimes(1)
+        verify("createBox").withTimes(1)
+    }
+
+    @Test
+    fun should_get_source_method_name() {
+        // synchronous
+        assertEquals("mock_one_mock_others", demoMock.callerOne() + "_" + demoMock.callerTwo())
+        // asynchronous
+        assertEquals("mock_one_mock_others", Executors.newSingleThreadExecutor().submit<String> {
+            demoMock.callerOne() + "_" + demoMock.callerTwo()
+        }.get())
+        verify("callFromDifferentMethod").withTimes(4)
+    }
+
+    @Test
+    fun should_get_test_case_name() {
+        MOCK_CONTEXT["case"] = "special_case"
+        // synchronous
+        assertEquals("mock_special", demoMock.callerOne())
+        // asynchronous
+        assertEquals("mock_special", Executors.newSingleThreadExecutor().submit<String> {
+            demoMock.callerOne()
+        }.get())
+        verify("callFromDifferentMethod").withTimes(2)
+        MOCK_CONTEXT.clear()
+    }
+}

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

@@ -0,0 +1,46 @@
+package com.alibaba.demo.basic
+
+import com.alibaba.testable.core.tool.PrivateAccessor
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+/**
+ * 演示私有成员访问功能
+ * Demonstrate private member access functionality
+ */
+internal class DemoPrivateAccessorTest {
+
+    private val demoPrivateAccess = DemoPrivateAccess()
+
+    @Test
+    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_access_private_field() {
+        PrivateAccessor.set(demoPrivateAccess, "count", 3)
+        assertEquals(3, PrivateAccessor.get(demoPrivateAccess, "count"))
+    }
+
+    @Test
+    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_access_private_static_field() {
+        PrivateAccessor.setStatic(DemoPrivateAccess::class.java, "staticCount", 3)
+        assertEquals(3, PrivateAccessor.getStatic(DemoPrivateAccess::class.java, "staticCount"))
+    }
+
+    @Test
+    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

@@ -0,0 +1,63 @@
+package com.alibaba.demo.basic
+
+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.*
+
+/**
+ * 演示模板方法的Mock场景
+ * Demonstrate scenario of mocking template method
+ */
+internal class DemoTemplateTest {
+
+    private val demoTemplate = DemoTemplate()
+
+    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)
+        }
+
+        @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
+        }
+    }
+
+    @Test
+    fun should_mock_single_template_method() {
+        val res = demoTemplate.singleTemplateMethod()
+        Assertions.assertEquals("demo_mock_list", res)
+    }
+
+    @Test
+    fun should_mock_double_template_method() {
+        val res = demoTemplate.doubleTemplateMethod()
+        Assertions.assertEquals("testable_mock_map", res)
+    }
+
+    @Test
+    fun should_mock_new_template_method() {
+        val res = demoTemplate.newTemplateMethod()
+        Assertions.assertEquals(2, res.size)
+        val iterator = res.stream().iterator()
+        Assertions.assertEquals("insert_mock", iterator.next())
+        Assertions.assertEquals("world_mocked", iterator.next())
+    }
+
+}

demo/kotlin-demo/src/test/kotlin/com/alibaba/demo/java2kotlin/PathUtilTest.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 PathUtilTest {
+
+    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() {
+        PathUtil.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,86 +0,0 @@
-package com.alibaba.testable.demo
-
-import com.alibaba.testable.core.annotation.TestableMock
-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
-
-internal class DemoInheritTest {
-
-    @TestableMock(targetMethod = "put")
-    private fun put_into_box(self: Box, something: String) {
-        self.put("put_" + something + "_into_box")
-    }
-
-    @TestableMock(targetMethod = "put")
-    private fun put_into_blackbox(self: BlackBox, something: String) {
-        self.put("put_" + something + "_into_blackbox")
-    }
-
-    @TestableMock(targetMethod = "get")
-    private fun get_from_box(self: Box): String {
-        return "get_from_box"
-    }
-
-    @TestableMock(targetMethod = "get")
-    private fun get_from_blackbox(self: BlackBox): String {
-        return "get_from_blackbox"
-    }
-
-    @TestableMock(targetMethod = "getColor")
-    private fun get_color_from_color(self: Color): String {
-        return "color_from_color"
-    }
-
-    @TestableMock(targetMethod = "getColor")
-    private fun get_color_from_blackbox(self: BlackBox): String {
-        return "color_from_blackbox"
-    }
-
-    private val demoInherit = DemoInherit()
-
-    @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/DemoMockTest.kt

@@ -1,101 +0,0 @@
-package com.alibaba.testable.demo
-
-import com.alibaba.testable.core.annotation.TestableMock
-import com.alibaba.testable.core.matcher.InvokeVerifier.verify
-import com.alibaba.testable.core.tool.TestableTool.*
-import com.alibaba.testable.demo.model.BlackBox
-import com.alibaba.testable.demo.model.ColorBox
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import java.util.concurrent.Executors
-
-internal class DemoMockTest {
-
-    @TestableMock(targetMethod = CONSTRUCTOR)
-    private fun createBlackBox(text: String) = BlackBox("mock_$text")
-
-    @TestableMock
-    private fun innerFunc(self: DemoMock, text: String) = "mock_$text"
-
-    @TestableMock
-    private fun trim(self: BlackBox) = "trim_string"
-
-    @TestableMock(targetMethod = "substring")
-    private fun sub(self: BlackBox, i: Int, j: Int) = "sub_string"
-
-    @TestableMock
-    private fun startsWith(self: BlackBox, s: String) = false
-
-    @TestableMock
-    private fun secretBox(ignore: BlackBox): BlackBox {
-        return BlackBox("not_secret_box")
-    }
-
-    @TestableMock
-    private fun createBox(ignore: ColorBox, color: String, box: BlackBox): BlackBox {
-        return BlackBox("White_${box.get()}")
-    }
-
-    @TestableMock
-    private fun callFromDifferentMethod(self: DemoMock): String {
-        return if (TEST_CASE == "should_able_to_get_test_case_name") {
-            "mock_special"
-        } else {
-            when (SOURCE_METHOD) {
-                "callerOne" -> "mock_one"
-                else -> "mock_others"
-            }
-        }
-    }
-
-    private val demoMock = DemoMock()
-
-    @Test
-    fun should_able_to_mock_new_object() {
-        assertEquals("mock_something", demoMock.newFunc())
-        verify("createBlackBox").with("something")
-    }
-
-    @Test
-    fun should_able_to_mock_member_method() {
-        assertEquals("{ \"res\": \"mock_hello\"}", demoMock.outerFunc("hello"))
-        verify("innerFunc").with("hello")
-    }
-
-    @Test
-    fun 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
-    fun should_able_to_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() {
-        // synchronous
-        assertEquals("mock_one_mock_others", demoMock.callerOne() + "_" + demoMock.callerTwo())
-        // asynchronous
-        assertEquals("mock_one_mock_others", Executors.newSingleThreadExecutor().submit<String> {
-            demoMock.callerOne() + "_" + demoMock.callerTwo()
-        }.get())
-        verify("callFromDifferentMethod").withTimes(4)
-    }
-
-    @Test
-    fun should_able_to_get_test_case_name() {
-        // synchronous
-        assertEquals("mock_special", demoMock.callerOne())
-        // asynchronous
-        assertEquals("mock_special", Executors.newSingleThreadExecutor().submit<String> {
-            demoMock.callerOne()
-        }.get())
-        verify("callFromDifferentMethod").withTimes(2)
-    }
-}

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

@@ -1,30 +0,0 @@
-package com.alibaba.testable.demo
-
-import com.alibaba.testable.core.accessor.PrivateAccessor
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-
-
-internal class DemoPrivateAccessTest {
-
-    private val demoPrivateAccess = DemoPrivateAccess()
-
-    @Test
-    fun should_able_to_access_private_method() {
-        assertEquals("hello - 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc", "hello", 1))
-    }
-
-    @Test
-    fun should_able_to_access_private_field() {
-        PrivateAccessor.set(demoPrivateAccess, "count", 3)
-        assertEquals("5", demoPrivateAccess.privateFieldAccessFunc())
-        assertEquals(5, PrivateAccessor.get(demoPrivateAccess, "count"))
-    }
-
-    @Test
-    fun should_able_to_update_final_field() {
-        PrivateAccessor.set(demoPrivateAccess, "pi", 4.13)
-        assertEquals(4.13, demoPrivateAccess.pi)
-    }
-
-}

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.TestableMock
-import com.alibaba.testable.core.matcher.InvokeVerifier.verify
-import org.junit.jupiter.api.Test
-import java.io.File
-
-class PathUtilTest {
-
-    @TestableMock
-    fun exists(f: File): Boolean {
-        return when (f.absolutePath) {
-            "/a/b" -> true
-            "/a/b/c" -> true
-            else -> f.exists()
-        }
-    }
-
-    @TestableMock
-    fun isDirectory(f: File): Boolean {
-        return when (f.absolutePath) {
-            "/a/b/c" -> true
-            else -> f.isDirectory
-        }
-    }
-
-    @TestableMock
-    fun delete(f: File): Boolean {
-        return true
-    }
-
-    @TestableMock
-    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)
-    }
-
-}

docs/en-us/README.md

@@ -0,0 +1,13 @@
+TestableMock Introduction
+---
+
+The mock method in unit testing is usually to bypass method calls that rely on external resources or irrelevant functions, so that the focus of the test can be keep on the code logic that needs to be verified and guaranteed.
+
+When defining the mock method, developers really care about only one thing: "<u>This call should be replaced with the fake **mock method** during testing</u>".
+
+However, when the current mainstream mock framework implements the mock function, developers have to worry about too many things: how the mock framework is initialized, whether it is compatible with the unit testing framework used, whether the method to be mocked is private or static, whether the object to be mocked is created by `new` operator or injected, how to send the mock object back to the class under test... These non-critical additional tasks greatly distract the fun of using the mock tool.
+
+Therefore, we developed `TestableMock`, **a maverick and lightweight mock tool**.
+
+
+![mock](https://testable-code.oss-cn-beijing.aliyuncs.com/en-us/mock-simpson.png)

docs/en-us/doc/about-us.md

@@ -0,0 +1,9 @@
+## About Us
+
+The core development team of `TestableMock` comes from **Alibaba Cloud · Cloud R&D Department** (formerly known as **Alibaba Group R&D Efficiency Department**). We not only internally support Alibaba Group's end-to-end project code, testing, and release process of thousands of BU-level product lines, but also the product R&D team of Alibaba Cloud enterprise-level R&D collaboration platform [云效](https://www.aliyun.com/product/yunxiao). As has been deeply involved in the field of developer tools, we are committed to improving the production experience of developers and building a digital R&D ecosystem for enterprises.
+
+The function of this project is inspired by our summary of the pain points that Java developers often encounter in daily unit testing ([external dependence on Mock is cumbersome](en-us/doc/use-mock.md), [private method is difficult to test](en-us/doc/private-accessor.md), [void type method is difficult to test](en-us/doc/test-void-method.md), and [complex parameters are difficult to construct](en-us/doc/parameter-constructor.md)). Its internal name is `Testable`, and was renamed `TestableMock` for SEO reason when it was open sourced, thus the lightweight mock function is highlighted. Don't be fooled by its name, `TestableMock` is more than just a mocking tool.
+
+From the incubation of hackathon, to internal open source, and then to external open source, `TestableMock` has accumulated a group of developer users in the internal and external communities. At the same time, we are constantly improving the functional richness and stability of `TestableMock` itself. According to the current version release process, we usually update the internal beta version containing the `SNAPSHOT` mark internally, and release the official version to the Maven central repository (except for the severe bug fix version) after at least one day of stable used to ensure the update will bring more convenience and less burden to everyone.
+
+Finally, we are relatively optimistic about the discussion in the community about "whether too powerful test assistance is equivalent to condoning code corruption". Just as the birth of `PowerMock` did not really spawn more bad projects, but actually solved many test problems left over by the Java language. Rather than use "code tricks" to test functions indirectly, it could be worth to just remove the constraints, and let the unit test break in all its fury! 🤠

docs/en-us/doc/annotations.md

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

docs/en-us/doc/comparation.md

@@ -0,0 +1,26 @@
+Mock Tools Comparison
+---
+
+Besides `TestableMock`, there are also several other community mock tools, such as `Mockito`, `Spock`, `PowerMock` and `JMockit`. Comparison as follows:
+
+|  Tool        | Mechanism                     | Minimal mock unit | Limitation of method be mocked               | Ease of use   | IDE support   |
+|  ----        | ----                          | ----              | ----                                         | ----          | ----          |
+| Mockito      | Dynamic proxy                 | Class             | Except private/static method and constructor | **Easy**      | **Very well** |
+| Spock        | Dynamic proxy                 | Class             | Except private/static method and constructor | Complicate    | Just so so    |
+| PowerMock    | Custom class loader           | Class             | **No limitation, any method works**          | Complicate    | **Good**      |
+| JMockit      | Runtime bytecode modification | Class             | Except constructor (i.e. new operator)       | Complicate    | Just so so    |
+| TestableMock | Runtime bytecode modification | Method            | **No limitation, any method works**          | **Very easy** | Just so so    |
+
+`Mockito` is Java's the most classical mock tool, good stability and easy to use, with both IntelliJ and Eclipse have plugin. The shortcoming part is that its mock functionality is sometimes not enough and have to be used in conjunction with other mock tools when necessary.
+
+`Spock` is a highly readable unit testing framework with built-in mock support, it has a good overall consistency. Since it is also based on dynamic proxy implementation, its shortcomings are similar to `Mockito`.
+
+`PowerMock` is a very powerful mock tool. Its basic syntax is compatible with `Mockito`, and extends many missing features of `Mockito`, including support for mocking of private, static and construction methods. However, due to the use of custom class loader, the test coverage of Jacoco will drop to zero in the default `on-the-fly` mode.
+
+`JMockit` is a mock tool whose functionality and convenience are between `Mockito` and `PowerMock`, and it makes up for their respective shortcomings. The project tried to launch a rewritten version of JMockit2 in 2017 but failed to complete, and is currently in an inactive maintenance state.
+
+The functionality of `TestabledMock` is basically the same as that of `PowerMock`, and it is extremely easy to use. You can complete most tasks only by mastering the annotations of `@MockMethod`.
+
+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 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,4 @@
+How Mock Works
+---
+
+TO BE TRANSLATED

docs/en-us/doc/feedback.md

@@ -0,0 +1,8 @@
+Feedback Channel
+---
+
+If you have any questions or suggestions during the use of `TestableMock`, please go ahead raise them at [Github Issues](https://github.com/alibaba/testable-mock/issues) and we will usually reply within 24 hours.
+
+Description of the situation you meet in detail is highly welcomed. If the problem may be related to a potential BUG of `TestableMock`, please try to provide reproducible source code or examples for shorten the troubleshooting time.
+
+`TestableMock`, with no more untestable code in Java : )

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

@@ -0,0 +1,54 @@
+Frequently Asked Questions
+---
+
+#### 1. How to mock the fields initialized by `@Autowired` in the class under test?
+
+Create the class under test object directly, and then use the ability of `TestableMock` to access private members to directly assign values to these fields.
+
+#### 2. Can `TestableMock` be used with other mock tools?
+
+`TestableMock` can be safely used together with other mock tools based on dynamic proxy mechanism, such as `Mockito`, `EasyMock`, `Spock`, etc., all belong to this category.
+
+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?
+
+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.
+
+At this time, follow a principle that the type of the first parameter of the mock method is always the same as the type of the variable that initiated the call.
+
+Therefore, regardless of whether the actually called method comes from the parent class or the subclass, and whether the subclass overrides the method. If the calling variable is of the parent type (or interface type), the first parameter type of the mock method should use the corresponding parent type (or interface) type.
+
+See the use case of the `DemoInheritTest` test class in the Java and Kotlin examples.
+
+#### 4. How to mock generic methods (template methods)?
+
+Just use the same generic parameters directly on the mock method.
+
+See the use case of the `DemoTemplateTest` test class in the Java and Kotlin examples.
+
+> 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. 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.
+
+#### 6. 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.
+
+#### 7. 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 "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`.
+
+![jar-manifest](https://testable-code.oss-cn-beijing.aliyuncs.com/jar-manifest.png)

docs/en-us/doc/invoke-matcher.md

@@ -0,0 +1,75 @@
+Verify Mock Invocation
+---
+
+In the test, in addition to replacing **methods contain external dependencies** with mocks, it is often necessary to verify whether the actual parameters of mock invocation are in accordance with expectations.
+
+The **verifiers** and **matchers** are provided in `TestableMock` to achieve this function. for example:
+
+```java
+@Test
+public test_case() {
+    int res = insToTest.methodToTest();
+    verify("mockMethod").with(123, "abc");
+}
+```
+
+This use case will check whether the mock method named `mockMethod` has been called when the method under test `methodToTest()` is executed, and whether the parameter values received during the call are `123` and `"abc"` (Assuming that the `mockMethod` method has two parameters).
+
+In addition to this simple verification, `TestableMock` currently supports a variety of **validators**, as well as **matchers** that can fuzzy match parameter characteristics.
+
+The `DemoMatcherTest` test classes in the sample projects `java-demo` and `kotlin-demo` show the usage of these validators and matchers in detail.
+
+## Basic validator
+
+- `with(Object...args)` → verify whether the method has been called by the specified parameters
+- `withInOrder(Object... args)` → verify the specified method is called with specified parameters according to the actual calling order
+- `withTimes(int expectedCount)` → verify whether the method has been called the specified number of times, ignoring the check of the calling parameters
+- `without(Object...args)` → verification method has never been called with specified parameters
+- `times(int count)` → use after the `with()` or `withInOrder()` method to verify that the method has been called the specified number of times with the same conditions
+
+## Basic matcher
+
+- `any()` → matches any value, including `null`
+- `any(Class<?> clazz)` → match any value of the specified type or subtype
+- `anyTypeOf(Class<?>... classes)` → match any type of value in the list
+- `anyString()` → matches any string
+- `anyNumber()` → matches any number (integer, long, float, double, etc)
+- `anyBoolean()` → matches any Boolean value
+- `anyByte()` → match any single byte type value
+- `anyChar()` → matches any single character type value
+- `anyInt()` → matches any integer value
+- `anyLong()` → matches any value of long integer type
+- `anyFloat()` → match any value of float type
+- `anyDouble()` → match any double-precision float number type value
+- `anyShort()` → matches any value of short integer type
+- `anyArray()` → matches any array
+- `anyArrayOf(Class<?> clazz)` → matches any array of the specified type
+- `anyList()` → matches any list
+- `anyListOf(Class<?> clazz)` → matches any list of the specified type
+- `anySet()` → matches any set
+- `anySetOf(Class<?> clazz)` → matches any set of the specified type
+- `anyMap()` → match any map
+- `anyMapOf(Class<?> keyClass, Class<?> valueClass)` → match any map of the specified type
+- `anyCollection()` → match any container
+- `anyCollectionOf(Class<?> clazz)` → matches any specified type of container
+- `anyIterable()` → matches any iterator
+- `anyIterableOf(Class<?> clazz)` → matches any iterator of the specified type
+- `eq(Object obj)` → match objects equal to the specified value
+- `refEq(Object obj)` → match the specified object (not equal to the value, but the same object)
+
+## Null value matcher
+
+- `isNull()` → match `null`
+- `notNull()` → matches any value except `null`
+- `nullable(Class<?> clazz)` → matches any value of `null` or specified type
+
+## String matcher
+
+- `contains(String substring)` → match a string containing a specific substring
+- `matches(String regex)` → match strings that match the specified regular expression
+- `endsWith(String suffix)` → match the string ending with the specified substring
+- `startsWith(String prefix)` → match the string starting with the specified substring
+
+## Universal matcher
+
+- `any(MatchFunction matcher)` → match the value that matches the specified expression

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,6 @@
+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.6` version.

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

@@ -0,0 +1,50 @@
+Private Accessor
+---
+
+Nowadays, the debate about whether private methods should be unit tested is gradually disappearing, and the common practice of developers has given factual answers. Indirect testing of private methods through public methods is difficult in many cases. Developers are more willing to modify method visibility to make original private methods testable in test cases.
+
+In addition, before unit testing begin, it is often necessary to initialize specific member fields of the object under test, but sometimes it could be impossible to easily assign values to these private fields. So, is it possible let the code in the unit test case directly access the private methods and member fields of the class under test without breaking the encapsulation of the type under test? `TestableMock` provides two simple solutions.
+
+### Solution 1: Use `@EnablePrivateAccess` annotation
+
+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)
+
+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 7 static methods:
+
+- `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

@@ -0,0 +1,128 @@
+# Release Note
+
+## 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`
+- fix a bug which may cause errors when the mock method contains array parameters
+- fix an issue which cause some private members not be found in the IntelliJ build
+
+## 0.4.10
+- fix an issue of using mock in lambda expression
+- fix the NullPointerException when invoke private method with parameter value `null`
+
+## 0.4.9
+- fix an issue cause by improperly bytecode processing while using `targetClass` parameter
+- auto validate access target of `PrivateAccessor`, improve resistance to code refactoring
+
+## 0.4.8
+- fix an issue of private method invocation failed in assignment statements
+- support using mock for testing with `SpringRunner`
+- support `targetClass` parameter in `@MockMethod` annotation
+
+## 0.4.7
+- fix incorrect stack size caused by `MOCK_CONTEXT` variable initialization
+- fix incorrect gradle build path of under Windows operating system
+
+## 0.4.6
+- fix an issue of `IINC` bytecode processing
+- support `TestableTool.MOCK_CONTEXT` variable to inject extra parameters to mock context
+- use `TestableTool.TEST_CASE` variable to distinguish test case is no longer recommended
+
+## 0.4.5
+- fix private access compile error in intelliJ 2020.3+ environment
+- change javaagent initialization logic to avoid NPE in cross-layer test scenario
+- support dump transformed byte code to local file for issue investigation
+
+## 0.4.4
+- fix an issue of accessing private method with interface type parameter fail
+- fix an issue of mocking static method without parameter fail 
+
+## 0.4.3
+- support static private member access
+
+## 0.4.2
+- support change javaagent global log level via maven plugin
+- fix an issue of duplicate test class injection
+- fix an issue cause multiple-line method invocation mock fail
+
+## 0.4.1
+- deprecate @TestableMock annotation, use @MockMethod and @MockConstructor instead
+
+## 0.4.0
+- fix a jvm 9+ compatibility issue cause by default classloader change
+- fix a conflict issue when testcase name duplicated between different class
+- refactor code structure, module `testable-all` added
+- separate constant definition from `TestableTool` to `TestableConst`
+
+## 0.3.2
+- support gradle project for both private member access and quick mock
+- support access private static field and methods via PrivateAccessor
+
+## 0.3.1
+- support detail log of mocking process for diagnosis
+
+## v0.3.0
+- add `without()` checker to verify mock method never invoked with specified parameters
+- support fuzz matcher when verifying mock invocation
+
+## v0.2.2
+- support mock method parameters check
+- fix a compatibility issue with jvm 9+
+
+## v0.2.1
+- support mock static method
+- support mock kotlin companion object method
+- support mock invoke by an interface / base class object
+
+## v0.2.0
+- use `TestableTool` class to expose test context and verify mock invoke
+- add `testable-maven-plugin` module to simplify javaagent configuration
+- remove dependence on `@EnableTestable` annotation in `testable-agent`
+- rename annotations to reflect the actual use
+
+## v0.1.0
+- move generated agent jar to class folder
+- support mock method of any object
+
+## v0.0.5
+- use dynamically runtime modification to replace static `e.java` file
+- get rid of unit test framework dependence
+- add testable ref field in test class at runtime instead of compile time
+
+## v0.0.4
+- use runtime byte code rewrite to invoke testable setup method
+- add `TestableUtil` class to fetch current test case and invocation source
+
+## v0.0.3
+- use global method invoke to access private members instead of modification in place
+- use `e.java` replace `testable` class make code more readable
+- introduce `agent` module, use runtime byte code modification to support new operation and member method mocking
+
+## v0.0.2
+- add support of member method mocking by compile time code modification
+
+## v0.0.1
+- PoC version
+- use compile time code modification to support new operation mocking and private field & method access

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

@@ -0,0 +1,95 @@
+Use TestableMock
+---
+
+`TestableMock` is an assist tool for Java unit testing based on source code and bytecode enhancement, 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
+
+## Use in Maven project
+
+In the project `pom.xml` file, add `testable-all` dependency and `maven-surefire-plugin` configuration, the specific method is as follows.
+
+It is recommended to add a `property` field that identifies the TestableMock version, in order to simplify version management:
+
+```xml
+<properties>
+    <testable.version>0.6.0</testable.version>
+</properties>
+```
+
+Add dependence of `TestableMock` inside `dependencies` field:
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>com.alibaba.testable</groupId>
+        <artifactId>testable-all</artifactId>
+        <version>${testable.version}</version>
+        <scope>test</scope>
+    </dependency>
+</dependencies>
+```
+
+Finally, add the `maven-surefire-plugin` plugin to the `plugins` list in the `build` area (if this plugin is already included, just add the `<argLine>` part of the configuration):
+
+```xml
+<build>
+    <plugins>
+        <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <configuration>
+                <argLine>-javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>
+            </configuration>
+        </plugin>
+    </plugins>
+</build>
+```
+
+If the project also uses the `on-the-fly` mode of `Jacoco` (default mode) to calculate the unit test coverage, you need to add a `@{argLine}` parameter in the `<argLine>` configuration, after adding it The configuration is as follows:
+
+```xml
+<argLine>@{argLine} -javaagent:${settings.localRepository}/com/alibaba/testable/testable-agent/${testable.version}/testable-agent-${testable.version}.jar</argLine>
+```
+
+See the [pom.xml](https://github.com/alibaba/testable-mock/blob/master/demo/java-demo/pom.xml) file of project `java-demo` and the [pom.xml](https://github.com/alibaba/testable-mock/blob/master/demo/kotlin-demo/pom.xml) file of project `kotlin-demo`.
+
+## Use in Gradle project
+
+Add dependence of `TestableMock` in `build.gradle` file:
+
+```groovy
+dependencies {
+    testImplementation('com.alibaba.testable:testable-all:0.6.0')
+    testAnnotationProcessor('com.alibaba.testable:testable-processor:0.6.0')
+}
+```
+
+Then add `javaagent` to "test" configuration：
+
+```groovy
+test {
+    jvmArgs "-javaagent:${classpath.find { it.name.contains("testable-agent") }.absolutePath}"
+}
+```
+
+See the [build.gradle](https://github.com/alibaba/testable-mock/blob/master/demo/java-demo/build.gradle) file of project `java-demo` and the [build.gradle.kts](https://github.com/alibaba/testable-mock/blob/master/demo/kotlin-demo/build.gradle.kts) file of project `kotlin-demo`.
+
+> For Android project tested with `Robolectric` framework, please use the same method to add `TestableMock` dependency as above, and add `javaagent` configuration as follows:
+>
+> ```groovy
+> android {
+>     testOptions {
+>         unitTests {
+>             all {
+>                 jvmArgs "-javaagent:${classpath.find { it.name.contains("testable-agent") }.absolutePath}"
+>             }
+>         }
+>     }
+> }
+> ```
+>
+> See [issue-43](https://github.com/alibaba/testable-mock/issues/43) for a complete example.

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

@@ -0,0 +1,96 @@
+Test Void Method
+---
+
+"How to test void type methods" has always been a topic that many unit testing frameworks are quietly avoiding. Since the existing unit testing methods are mainly to verify the returned results of the tested unit, when the method has no return value, there is no way to test.
+
+From a functional point of view, although the void method does not return any value, its execution will definitely have some potential impact on the outside world. We call it the "side effect" of the method, such as:
+
+1. Initialize external variables (private member variables or global static variables)
+2. Assign value to external object
+3. Print logs
+4. Invoke other external methods
+5. ... ...
+
+> A method that does not return any value and does not produce any "side effects" has no meaning to exist.
+
+The essence of these "side effects" can be summarized into two categories: **modify external variables** and **invoke external methods**.
+
+Through the private field accessor and the mock validator of `TestableMock`, the "side effects" can be easily checked.
+
+### 1. Void type method which modify external variables
+
+For example, the following method will modify the private member variable `hashCache` based on the input:
+
+```java
+class Demo {
+    private Map<String, Integer> hashCache = mapOf();
+
+    public void updateCache(String domain, String key) {
+        String cacheKey = domain + "::" + key;
+        Integer num = hashCache.get(cacheKey);
+        hashCache.put(cacheKey, count == null ? initHash(key) : nextHash(num, key));
+    }
+
+    ... // Other methods omitted
+}
+```
+
+To test this method, you can use `TestableMock` directly read the value of the private member variable and verify the result:
+
+```java
+@EnablePrivateAccess  // Enable private member access functionality of TestableMock
+class DemoTest {
+    private Demo demo = new Demo();
+
+    @Test
+    public void testSaveToCache() {
+        Integer firstVal = demo.initHash("hello"); // Invoke private method
+        Integer nextVal = demo.nextHash(firstVal, "hello"); // Invoke private method
+        demo.saveToCache("demo", "hello");
+        assertEquals(firstVal, demo.hashCache.get("demo::hello")); // Access private variable
+        demo.saveToCache("demo", "hello");
+        assertEquals(nextVal, demo.hashCache.get("demo::hello")); // Access private variable
+    }
+}
+```
+
+### 2. Void type method which invoke external method
+
+For example, the following method will print information to the console based on input:
+
+```java
+class Demo {
+    public void recordAction(Action action) {
+        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss ");
+        String timeStamp = df.format(new Date());
+        System.out.println(timeStamp + "[" + action.getType() + "] " + action.getTarget());
+    }
+}
+```
+
+To test this method, you can use `TestableMock` to quickly mock out the `System.out.println` method. In the mock method body, you can simply call the original method (equivalent to not affecting the original method function, only used for call recording), or leave it blank (equivalent to removing the side effects of the original method).
+
+After executing the void type method under test, use `InvokeVerifier.verify()` to verify whether the incoming print content meets expectations:
+
+```java
+class DemoTest {
+    private Demo demo = new Demo();
+
+    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
+    public void testRecordAction() {
+        Action action = new Action("click", ":download");
+        demo.recordAction();
+        // Verify mock method `println` is invoked, and passing parameters in line with expectations 
+        verify("println").with(matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2} \\[click\\] :download"));
+    }
+}
+```

docs/en-us/doc/troubleshooting.md

@@ -0,0 +1,94 @@
+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 `@MockDiagnose` annotation to the mock class, and set the value `LogLevel.ENABLE`, so the detailed mock method replacement process will be printed when the test is run.
+
+```java
+class DemoTest {
+    @MockDiagnose(LogLevel.ENABLE)
+    public static class Mock {
+        ...
+    }
+}
+```
+
+The output log example is as follows:
+
+```text
+[DIAGNOSE] Handling test class com/alibaba/testable/demo/basic/DemoMockTest
+[DIAGNOSE]   Found 6 test cases
+[DIAGNOSE] Handling mock class com/alibaba/testable/demo/basic/DemoMockTest$Mock
+[DIAGNOSE]   Found 8 mock methods
+[DIAGNOSE] Handling source class com/alibaba/testable/demo/basic/DemoMock
+[DIAGNOSE]   Handling method <init>
+[DIAGNOSE]   Handling method newFunc
+[DIAGNOSE]     Line 19, mock method "createBlackBox" used
+[DIAGNOSE]   Handling method outerFunc
+[DIAGNOSE]     Line 27, mock method "innerFunc" used
+[DIAGNOSE]     Line 27, mock method "staticFunc" used
+[DIAGNOSE]   Handling method commonFunc
+[DIAGNOSE]     Line 34, mock method "trim" used
+[DIAGNOSE]     Line 34, mock method "sub" used
+[DIAGNOSE]     Line 34, mock method "startsWith" used
+... ...
+```
+
+The log shows all the mocked invocation and corresponding code line numbers in the class under test.
+
+- Self troubleshooting:
+
+- 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 mock class` is output, please check whether the mock class is created at correct place
+- If `Handling mock class` and `Handling test class` are output, 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 `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
+
+For situations where expected mocking is not take effect, you could set the diagnosis level to `LogLevel.VERBOSE` for further investigation information.
+
+```java
+class DemoTest {
+    @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
+[DIAGNOSE] Handling test class com/alibaba/testable/demo/basic/DemoMockTest
+[VERBOSE]    Test case "should_mock_new_object"
+... ...
+[VERBOSE]    Test case "should_set_mock_context"
+[DIAGNOSE]   Found 6 test cases
+[DIAGNOSE] Handling mock class com/alibaba/testable/demo/basic/DemoMockTest$Mock
+[VERBOSE]    Mock constructor "createBlackBox" as "com.alibaba.demo.basic.model.mock.BlackBox(java.lang.String)"
+[VERBOSE]    Mock method "innerFunc" as "com.alibaba.demo.basic.DemoMock::innerFunc(java.lang.String) : java.lang.String"
+... ...
+[VERBOSE]    Mock method "callFromDifferentMethod" as "()Ljava/lang/String;"
+[DIAGNOSE]   Found 8 mock methods
+[DIAGNOSE] Handling source class com/alibaba/testable/demo/basic/DemoMock
+[DIAGNOSE]   Handling method <init>
+[VERBOSE]      Line 13, constructing "java.lang.Object()"
+[DIAGNOSE]   Handling method newFunc
+[VERBOSE]      Line 19, constructing "com.alibaba.demo.basic.model.mock.BlackBox(java.lang.String)"
+[DIAGNOSE]     Line 19, mock method "createBlackBox" used
+[VERBOSE]      Line 19, invoking "com.alibaba.demo.basic.DemoMockTest$Mock::createBlackBox(java.lang.String) : com.alibaba.demo.basic.model.mock.BlackBox"
+[VERBOSE]      Line 20, invoking "com.alibaba.demo.basic.model.mock.BlackBox::get() : java.lang.String"
+[DIAGNOSE]   Handling method outerFunc
+[VERBOSE]      Line 27, constructing "java.lang.StringBuilder()"
+[VERBOSE]      Line 27, invoking "java.lang.StringBuilder::append(java.lang.String) : java.lang.StringBuilder"
+[VERBOSE]      Line 27, invoking "com.alibaba.demo.basic.DemoMock::innerFunc(java.lang.String) : java.lang.String"
+[DIAGNOSE]     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

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-in-ide.md

@@ -0,0 +1,18 @@
+Use TestableMock In IDE
+---
+
+## Use IntelliJ IDE
+
+IntelliJ IDE supports the `JSR-269` annotation processor and the `maven-surefire-plugin` arguments very well (both are techniques back the `TestableMock`). Usually you don't need any special configuration to make everything work, it's all out of the box.
+
+## Use Eclipse IDE
+
+Since the built-in compilation feature of `Eclipse` is based on a self-made compiler, it is not compatible with the standard `javac` compilation process, which will cause the `@EnablePrivateAccess` annotation to be invalid when running test cases in the IDE. However, the function of accessing the private members of the class under test through the `PrivateAccessor` tool class will not be affected by differences in the compiler.
+
+If the `@EnablePrivateAccess` annotation is used in the project, you can use `mvn test -Dtest=<TestClassName>` and `mvn test -Dtest=<TestClassName>#<TestCaseName>` in the command line of `Eclipse` to run a single test class or test case.
+
+At the same time, because the built-in unit test executor of `Eclipse` completely ignores the configuration of the `pom.xml` file, additional configuration is required to use the Mock function.
+
+Take the use of `JUnit` as an example. You need to pull down from the small triangle next to the run button on the IDE toolbar, select "Run Configurations...", select the task to run the unit test on the left side, and switch to "arguments" Tab on the right side, append a `-javaagent:` parameter in the "VM Options", the following figure is an example, note that the `testable-agent` package should be modified to match the actual situation of the local Maven repository path.
+
+![eclipse-junit-configuration](https://testable-code.oss-cn-beijing.aliyuncs.com/eclipse-junit-configuration.png)

docs/en-us/doc/use-maven-plugin.md

@@ -0,0 +1,42 @@
+Testable Maven Plugin
+---
+
+For projects built with Maven, in addition to directly modifying the argument of the `maven-surefire-plugin` plugin, the same effect can also be obtained through the `testable-maven-plugin` plugin:
+
+```xml
+<plugin>
+    <groupId>com.alibaba.testable</groupId>
+    <artifactId>testable-maven-plugin</artifactId>
+    <version>${testable.version}</version>
+    <executions>
+        <execution>
+            <id>prepare</id>
+            <goals>
+                <goal>prepare</goal>
+            </goals>
+        </execution>
+    </executions>
+</plugin>
+```
+
+> When using `testable-maven-plugin`, the `TestableMock` related configuration on `maven-surefire-plugin` should be removed.
+
+The `testable-maven-plugin` can be used with the Jacoco plugin without additional adaptation, so it can make the writing of the `pom.xml` file easier and more readable.
+
+However, it should be noted that when running a single test case through the IDE, those mock function may fail to work.
+
+This is because the IDE usually only runs the `maven-surefire-plugin` plugin when running a single test case, skipping the execution of the `testable-maven-plugin` plugin, resulting in the JavaAgent required for the mock function not being injected into the context.
+
+This problem can be bypassed by configuring the test parameters of the IDE additionally. Take IntelliJ as an example, open the "Edit Configuration..." option of the run menu, as shown in the position ①
+
+![modify-run-configuration](https://testable-code.oss-cn-beijing.aliyuncs.com/modify-run-configuration.png)
+
+Add JavaAgent startup parameters at the end of the "virtual machine parameters" attribute value: `-javaagent:${HOME}/.m2/repository/com/alibaba/testable/testable-agent/xyz/testable-agent-xyzjar`, as shown in the figure position ②
+
+> PS: Please replace `x.y.z` in the path with the actual version number
+
+![add-testable-javaagent](https://testable-code.oss-cn-beijing.aliyuncs.com/add-testable-javaagent.png)
+
+Finally, click to run the unit test, as shown in the position ③
+
+In general, the additional complexity of using `testable-maven-plugin` is still higher than its simplified configuration. At present, modify the configuration of the `maven-surefire-plugin` directly in the `pom.xml` file is still the preferred solution.

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

@@ -0,0 +1,167 @@
+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 summary, there are two simple rules:
+> - 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.
+
+### 0. Pre-step, prepare the mock class
+
+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 mock class:
+
+```java
+// The original method signature is `String substring(int, int)`
+// The object `"anything"` that invokes this method is of type `String`
+@MockMethod(targetClass = String.class)
+private String substring(int i, int j) {
+    return "sub_string";
+}
+```
+
+When several methods to be mocked have the same name, you can put the name of the method to be mocked in the `targetMethod` parameter of `@MockMethod` annotation, so that the mock method itself can be named at will.
+
+The following example shows the usage of the `targetMethod` parameter, and its effect is the same as the above example:
+
+```java
+// Use `targetMethod` to specify the name of the method that needs to be mocked
+// The method itself can now be named arbitrarily, but the method parameters still need to follow the same matching rules
+@MockMethod(targetClass = String.class, targetMethod = "substring")
+private String use_any_mock_method_name(int i, int j) {
+    return "sub_string";
+}
+```
+
+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:
+
+```java
+// Adds a `String` type parameter to the first position the mock method parameter list (parameter name is arbitrary)
+// This parameter can be used to get the value and context of the actual invoker at runtime
+@MockMethod
+private String substring(String self, int i, int j) {
+    // Call the original method is also allowed
+    return self.substring(i, j);
+}
+```
+
+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)
+
+### 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 mock class:
+
+```java
+// The type to test is `DemoMock`
+@MockMethod(targetClass = DemoMock.class)
+private String innerFunc(String text) {
+    return "mock_" + 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_mock_member_method()` test case in the `java-demo` and `kotlin-demo` sample projects.
+
+### 1.3 Mock static methods of any class
+
+Mock for static methods is the same as for any ordinary methods.
+
+For example, if the static method `secretBox()` of the `BlackBox` type is invoked in the class under test, and the method signature is `BlackBox secretBox()`, then the mock method is as follows:
+
+```java
+@MockMethod(targetClass = BlackBox.class)
+private BlackBox secretBox() {
+    return new BlackBox("not_secret_box");
+}
+```
+
+For complete code examples, see the `should_mock_static_method()` test case in the `java-demo` and `kotlin-demo` sample projects.
+
+### 1.4 Mock `new` operation of any type
+
+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.
+
+For example, if there is a call to `new BlackBox("something")` in the class under test, and you want to change it during unit testing (usually by replacing it with a mock object, or by replacing it with a temporary object created with test parameters), just define the following mock method:
+
+```java
+// The signature of the constructor to be mocked is `BlackBox(String)`
+// No need to add additional parameters to the mock method parameter list, and the name of the mock method is arbitrary 
+@MockContructor
+private BlackBox createBlackBox(String text) {
+    return new BlackBox("mock_" + 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_mock_new_object()` test case in the `java-demo` and `kotlin-demo` sample projects.
+
+### 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.
+
+For example, to verify the impact on the target method under test when the mock method returns different results in the test case:
+
+```java
+@Test
+public void testDemo() {
+    MOCK_CONTEXT.set("case", "data-ready");
+    assertEquals(true, demo());
+    MOCK_CONTEXT.set("case", "has-error");
+    assertEquals(false, demo());
+}
+```
+
+Take out the injected parameters in the mock method and return different results according to the situation:
+
+```java
+@MockMethod
+private Data mockDemo() {
+    switch((String)MOCK_CONTEXT.get("case")) {
+        case "data-ready":
+            return new Data();
+        case "has-error":
+            throw new NetworkException();
+        default:
+            return null;
+    }
+}
+```
+
+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.
+
+### 3. 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.
+
+For details, please refer to the [Check Mock Call](en-us/doc/matcher.md) document.
+

docs/en-us/navbar.md

@@ -0,0 +1,5 @@
+* [Home](/en-us/)
+* [Feedback And Issue](https://github.com/alibaba/testable-mock/issues)
+* Languages
+    * English
+    * [中文](/zh-cn/)

docs/en-us/sidebar.md

@@ -0,0 +1,26 @@
+- Quick Start
+  - [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)
+
+- 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)
+  - [Feedback Channel](en-us/doc/feedback.md)

docs/index.html

@@ -14,7 +14,7 @@
 <div id="app">Loading...</div>
 <script>
   window.$docsify = {
-    name: 'Testable',
+    name: 'TestableMock',
     repo: 'https://github.com/alibaba/testable-mock',
     loadSidebar: "sidebar.md",
     loadNavbar: "navbar.md",
@@ -26,13 +26,14 @@
         hook.beforeEach(function (html) {
           return html
             + '\n\n----\n\n'
-            + '<a href="https://devops.aliyun.com" target="_blank" style="color: inherit; font-weight: normal; text-decoration: none;">Powered by 云效</a>'
+            + '<a href="https://www.aliyun.com/product/yunxiao" target="_blank" style="color: inherit; font-weight: normal; text-decoration: none;">Powered by 云效</a>'
         })
       }
     ]
   }
 </script>
 <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
+<script src="//unpkg.com/prismjs/components/prism-java.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/docsify-tabs@1"></script>
 <script async defer src="https://buttons.github.io/buttons.js"></script>
 </body>

docs/zh-cn/README.md

@@ -1,12 +1,12 @@
 TestableMock简介
 ---
 
-单元测试中的Mock方法，通常是为了绕开那些依赖外部资源或无关功能的方法调用，使得测试重点能够集中在需要验证和保障的代码逻辑上。
+单元测试中的Mock方法，通常是为了绕开那些依赖外部资源或无关功能的方法调用，使得测试重点能够集中在需要验证和保障的代码逻辑上。某个调用需要被Mock，往往只与其自身特征有关，而与调用的来源无关。
 
 在定义Mock方法时，开发者真正关心的只有一件事："<u>这个调用，在测试的时候要换成那个假的Mock方法</u>"。
 
-然而当下主流的Mock框架在实现Mock功能时，需要开发者操心的事情实在太多：Mock框架如何初始化、与所用的单元测试框架是否兼容、要被Mock的方法是不是私有的、是不是静态的、被Mock对象是new出来的还是注入的、怎样把被测对象送回被测类里...这些非关键的额外工作极大分散了使用Mock工具应有的乐趣。
+当下主流的Mock框架在实现Mock功能时，需要开发者操心的事情实在太多：Mock框架如何初始化、与所用的服务框架是否兼容、要被Mock的方法是不是私有的、是不是静态的、被Mock对象是new出来的还是注入的、怎样把被测对象送回被测类里...这些非关键的额外工作极大分散了使用Mock工具应有的乐趣。
 
 于是，我们开发了`TestableMock`，**一款特立独行的轻量Mock工具**。
 
-![mock](https://testable-code.oss-cn-beijing.aliyuncs.com/mock.jpg)
+![mock](https://testable-code.oss-cn-beijing.aliyuncs.com/mock-simpson.png)

docs/zh-cn/doc/about-us.md

@@ -0,0 +1,9 @@
+## 关于我们
+
+`TestableMock`的核心开发团队来自**阿里云·云研发部**（前身为**阿里集团研发效能部**）。我们不仅对内支持阿里数万名技术小二每天从任务分配、代码提交、功能测试、到产品发布的全生命周期流程，同时也是阿里云企业级研发协同平台[云效](https://www.aliyun.com/product/yunxiao)的产品研发团队，一直深耕在开发者工具领域，致力于改善开发者生产体验和构筑企业数字化研发生态。
+
+这个项目的原始灵感来自于我们对Java开发者在日常单元测试中经常遇到的痛点总结（[外部依赖Mock繁琐](zh-cn/doc/use-mock.md)、[私有方法难测试](zh-cn/doc/private-accessor.md)、[无返回值方法难测试](zh-cn/doc/test-void-method.md)、[复杂参数难构造](zh-cn/doc/parameter-constructor.md)）。它在内部的名字是`Testable`，开源时为了搜索引擎优化，改名为`TestableMock`，并主推轻量级Mock功能。 不要被它的名字所迷惑，`TestableMock`绝不仅仅是Mock。
+
+从黑客马拉松孵化，到内部开源，再到对外开源，`TestableMock`已经积累了一批阿里集团内部和外部社区的开发者用户。与此同时，我们也在不断完善`TestableMock`自身的功能丰富性和稳定性。按照当前的版本发布计划，每次新版本发布前会首先提交包含`SNAPSHOT`标记的内测版到内部仓库，在至少稳定使用一天以后，才会成为正式版提交到Maven中心仓库（紧急BUG修复版本除外），以确保工具在为大家带来更多便捷的同时具有足够的可靠性。
+
+最后，关于社区里有对“破坏封装进行单元测试是否等同于纵容代码腐化”的讨论，我们持相对乐观的态度。正如`PowerMock`的诞生并没有真的催生更多烂项目，反而切实解决了许多Java语言遗留的测试难题。与其束手束脚的采用“测试技巧”间接测试功能，不如索性解除限制，就让单元测试来得更猛烈一些吧！🤠

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容器关联测试用例的诊断日志级别 |
+