use standalone mock class in demos

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

@@ -17,36 +17,37 @@ class DemoInheritTest {
 
     private DemoInherit demoInherit = new DemoInherit();
 
-    @MockMethod(targetMethod = "put")
-    private void put_into_box(Box self, String something) {
-        self.put("put_" + something + "_into_box");
-    }
+    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 = "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_box(Box self) {
+            return "get_from_box";
+        }
 
-    @MockMethod(targetMethod = "get")
-    private String get_from_blackbox(BlackBox self) {
-        return "get_from_blackbox";
-    }
+        @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_color(Color self) {
+            return "color_from_color";
+        }
 
-    @MockMethod(targetMethod = "getColor")
-    private String get_color_from_blackbox(BlackBox self) {
+        @MockMethod(targetMethod = "getColor")
+        private String get_color_from_blackbox(BlackBox self) {
         return "color_from_blackbox";
     }
-
+    }
 
     @Test
     void should_able_to_mock_call_sub_object_method_by_parent_object() {

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

@@ -17,15 +17,16 @@ class DemoMatcherTest {
 
     private DemoMatcher demoMatcher = new DemoMatcher();
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private void methodWithoutArgument(DemoMatcher self) {}
+    public static class Mock {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithoutArgument(DemoMatcher self) {}
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private void methodWithArguments(DemoMatcher self, Object a1, Object a2) {}
-
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private void methodWithArrayArgument(DemoMatcher self, Object[] a) {}
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithArguments(DemoMatcher self, Object a1, Object a2) {}
 
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private void methodWithArrayArgument(DemoMatcher self, Object[] a) {}
+    }
 
     @Test
     void should_match_no_argument() {

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

@@ -20,53 +20,56 @@ class DemoMockTest {
 
     private DemoMock demoMock = new DemoMock();
 
-    @MockConstructor
-    private BlackBox createBlackBox(String text) {
-        return new BlackBox("mock_" + text);
-    }
-
-    @MockMethod(targetClass = DemoMock.class)
-    private String innerFunc(String text) {
-        return "mock_" + text;
-    }
-
-    @MockMethod(targetClass = DemoMock.class)
-    private String staticFunc() {
-        return "_MOCK_TAIL";
-    }
-
-    @MockMethod(targetClass = String.class)
-    private String trim() {
-        return "trim_string";
-    }
-
-    @MockMethod(targetClass = String.class, targetMethod = "substring")
-    private String sub(int i, int j) {
-        return "sub_string";
-    }
-
-    @MockMethod(targetClass = String.class)
-    private boolean startsWith(String s) {
-        return false;
-    }
-
-    @MockMethod(targetClass = BlackBox.class)
-    private BlackBox secretBox() {
-        return new BlackBox("not_secret_box");
-    }
-
-    @MockMethod(targetClass = DemoMock.class)
-    private String callFromDifferentMethod() {
-        if ("special_case".equals(MOCK_CONTEXT.get("case"))) {
-            return "mock_special";
+    public static class Mock {
+        @MockConstructor
+        private BlackBox createBlackBox(String text) {
+            return new BlackBox("mock_" + text);
         }
-        switch (SOURCE_METHOD) {
-            case "callerOne": return "mock_one";
-            default: return "mock_others";
+
+        @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_able_to_mock_new_object() {
         assertEquals("mock_something", demoMock.newFunc());

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

@@ -16,59 +16,60 @@ class DemoTemplateTest {
 
     private DemoTemplate demoTemplate = new DemoTemplate();
 
-    /* 第一种写法：使用泛型定义 */
-    /* First solution: use generics type */
+    public static class Mock {
+        /* 第一种写法：使用泛型定义 */
+        /* First solution: use generics type */
 
-    @MockMethod
-    private static <T> List<T> getList(DemoTemplate self, T value) {
-        return new ArrayList<T>() {{ add((T)(value.toString() + "_mock_list")); }};
+        @MockMethod
+        private <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;
+        //}
     }
 
-    @MockMethod
-    private static <K, V> Map<K, V> getMap(DemoTemplate self, K key, V value) {
-        return new HashMap<K, V>() {{ put(key, (V)(value.toString() + "_mock_map")); }};
-    }
-
-    @MockConstructor
-    private <T> HashSet<T> newHashSet() {
-        HashSet<T> set = new HashSet<>();
-        set.add((T)"insert_mock");
-        return set;
-    }
-
-    @MockMethod
-    private <E> boolean add(Set s, E e) {
-        s.add(e.toString() + "_mocked");
-        return true;
-    }
-
-    /* 第二种写法：使用Object类型 */
-    /* Second solution: use object type */
-
-    //@MockMethod
-    //private static List<Object> getList(DemoTemplate self, Object value) {
-    //    return new ArrayList<Object>() {{ add(value.toString() + "_mock_list"); }};
-    //}
-    //
-    //@MockMethod
-    //private static Map<Object, Object> getMap(DemoTemplate self, Object key, Object value) {
-    //    return new HashMap<Object, Object>() {{ put(key, value.toString() + "_mock_map"); }};
-    //}
-    //
-    //@MockConstructor
-    //private HashSet newHashSet() {
-    //    HashSet<Object> set = new HashSet<>();
-    //    set.add("insert_mock");
-    //    return set;
-    //}
-    //
-    //@MockMethod
-    //private boolean add(Set s, Object e) {
-    //    s.add(e.toString() + "_mocked");
-    //    return true;
-    //}
-
-
     @Test
     void should_able_to_mock_single_template_method() {
         String res = demoTemplate.singleTemplateMethod();

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

@@ -16,37 +16,38 @@ internal class DemoInheritTest {
 
     private val demoInherit = DemoInherit()
 
-    @MockMethod(targetMethod = "put")
-    private fun put_into_box(self: Box, something: String) {
-        self.put("put_" + something + "_into_box")
-    }
+    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 = "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_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 = "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_color(self: Color): String {
+            return "color_from_color"
+        }
 
-    @MockMethod(targetMethod = "getColor")
-    private fun get_color_from_blackbox(self: BlackBox): String {
-        return "color_from_blackbox"
+        @MockMethod(targetMethod = "getColor")
+        private fun get_color_from_blackbox(self: BlackBox): String {
+            return "color_from_blackbox"
+        }
     }
 
-
     @Test
     fun should_able_to_mock_call_sub_object_method_by_parent_object() {
         val box = demoInherit.putIntoBox() as BlackBox

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

@@ -16,19 +16,20 @@ internal class DemoMatcherTest {
 
     private val demoMatcher = DemoMatcher()
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private fun methodWithoutArgument(self: DemoMatcher) {
-    }
+    class Mock {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithoutArgument(self: DemoMatcher) {
+        }
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private fun methodWithArguments(self: DemoMatcher, a1: Any, a2: Any) {
-    }
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithArguments(self: DemoMatcher, a1: Any, a2: Any) {
+        }
 
-    @MockMethod(targetMethod = "methodToBeMocked")
-    private fun methodWithArrayArgument(self: DemoMatcher, a: Array<Any>) {
+        @MockMethod(targetMethod = "methodToBeMocked")
+        private fun methodWithArrayArgument(self: DemoMatcher, a: Array<Any>) {
+        }
     }
 
-
     @Test
     fun should_match_no_argument() {
         demoMatcher.callMethodWithoutArgument()

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

@@ -19,49 +19,50 @@ internal class DemoMockTest {
 
     private val demoMock = DemoMock()
 
-    @MockConstructor
-    private fun createBlackBox(text: String) = BlackBox("mock_$text")
+    class Mock {
+        @MockConstructor
+        private fun createBlackBox(text: String) = BlackBox("mock_$text")
 
-    @MockMethod(targetClass = DemoMock::class)
-    private fun innerFunc(text: String) = "mock_$text"
+        @MockMethod(targetClass = DemoMock::class)
+        private fun innerFunc(text: String) = "mock_$text"
 
-    @MockMethod(targetClass = DemoMock::class)
-    private fun staticFunc(): String {
-        return "_MOCK_TAIL";
-    }
+        @MockMethod(targetClass = DemoMock::class)
+        private fun staticFunc(): String {
+            return "_MOCK_TAIL";
+        }
 
-    @MockMethod(targetClass = BlackBox::class)
-    private fun trim() = "trim_string"
+        @MockMethod(targetClass = BlackBox::class)
+        private fun trim() = "trim_string"
 
-    @MockMethod(targetClass = BlackBox::class, targetMethod = "substring")
-    private fun sub(i: Int, j: Int) = "sub_string"
+        @MockMethod(targetClass = BlackBox::class, targetMethod = "substring")
+        private fun sub(i: Int, j: Int) = "sub_string"
 
-    @MockMethod(targetClass = BlackBox::class)
-    private fun startsWith(s: String) = false
+        @MockMethod(targetClass = BlackBox::class)
+        private fun startsWith(s: String) = false
 
-    @MockMethod(targetClass = BlackBox::class)
-    private fun secretBox(): BlackBox {
-        return BlackBox("not_secret_box")
-    }
+        @MockMethod(targetClass = BlackBox::class)
+        private fun secretBox(): BlackBox {
+            return BlackBox("not_secret_box")
+        }
 
-    @MockMethod(targetClass = ColorBox::class)
-    private fun createBox(color: String, box: BlackBox): BlackBox {
-        return BlackBox("White_${box.get()}")
-    }
+        @MockMethod(targetClass = ColorBox::class)
+        private fun createBox(color: String, box: BlackBox): BlackBox {
+            return BlackBox("White_${box.get()}")
+        }
 
-    @MockMethod(targetClass = DemoMock::class)
-    private fun callFromDifferentMethod(): String {
-        return if (MOCK_CONTEXT["case"] == "special_case") {
-            "mock_special"
-        } else {
-            when (SOURCE_METHOD) {
-                "callerOne" -> "mock_one"
-                else -> "mock_others"
+        @MockMethod(targetClass = DemoMock::class)
+        private fun callFromDifferentMethod(): String {
+            return if (MOCK_CONTEXT["case"] == "special_case") {
+                "mock_special"
+            } else {
+                when (SOURCE_METHOD) {
+                    "callerOne" -> "mock_one"
+                    else -> "mock_others"
+                }
             }
         }
     }
 
-
     @Test
     fun should_able_to_mock_new_object() {
         assertEquals("mock_something", demoMock.newFunc())

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

@@ -14,30 +14,31 @@ internal class DemoTemplateTest {
 
     private val demoTemplate = DemoTemplate()
 
-    @MockMethod
-    private fun <T> getList(self: DemoTemplate, value: T): List<T> {
-        return mutableListOf((value.toString() + "_mock_list") as T)
-    }
+    class Mock {
+        @MockMethod
+        private fun <T> getList(self: DemoTemplate, value: T): List<T> {
+            return mutableListOf((value.toString() + "_mock_list") as T)
+        }
 
-    @MockMethod
-    private fun <K, V> getMap(self: DemoTemplate, key: K, value: V): Map<K, V> {
-        return mutableMapOf(key to (value.toString() + "_mock_map") as V)
-    }
+        @MockMethod
+        private fun <K, V> getMap(self: DemoTemplate, key: K, value: V): Map<K, V> {
+            return mutableMapOf(key to (value.toString() + "_mock_map") as V)
+        }
 
-    @MockConstructor
-    private fun newHashSet(): HashSet<*> {
-        val set = HashSet<Any>()
-        set.add("insert_mock")
-        return set
-    }
+        @MockConstructor
+        private fun newHashSet(): HashSet<*> {
+            val set = HashSet<Any>()
+            set.add("insert_mock")
+            return set
+        }
 
-    @MockMethod
-    private fun <E> add(s: MutableSet<E>, e: E): Boolean {
-        s.add((e.toString() + "_mocked") as E)
-        return true
+        @MockMethod
+        private fun <E> add(s: MutableSet<E>, e: E): Boolean {
+            s.add((e.toString() + "_mocked") as E)
+            return true
+        }
     }
 
-
     @Test
     fun should_able_to_mock_single_template_method() {
         val res = demoTemplate.singleTemplateMethod()

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

@@ -7,34 +7,36 @@ import java.io.File
 
 class PathUtilTest {
 
-    @MockMethod
-    fun exists(f: File): Boolean {
-        return when (f.absolutePath) {
-            "/a/b" -> true
-            "/a/b/c" -> true
-            else -> f.exists()
+    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 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 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()
+        @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()
+            }
         }
     }