From 74e3cf16a4170a19a19a852d7ded439eb85a4241 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=87=91=E6=88=9F?= Date: Thu, 11 Feb 2021 14:52:19 +0800 Subject: [PATCH] use standalone mock class in demos --- .../testable/demo/DemoInheritTest.java | 47 ++++---- .../testable/demo/DemoMatcherTest.java | 15 +-- .../alibaba/testable/demo/DemoMockTest.java | 89 +++++++-------- .../testable/demo/DemoTemplateTest.java | 101 +++++++++--------- .../alibaba/testable/demo/DemoInheritTest.kt | 49 ++++----- .../alibaba/testable/demo/DemoMatcherTest.kt | 19 ++-- .../com/alibaba/testable/demo/DemoMockTest.kt | 63 +++++------ .../alibaba/testable/demo/DemoTemplateTest.kt | 39 +++---- .../testable/demo/util/PathUtilTest.kt | 48 +++++---- 9 files changed, 241 insertions(+), 229 deletions(-) diff --git a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoInheritTest.java b/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoInheritTest.java index 6c6da70..f7b4e44 100644 --- a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoInheritTest.java +++ b/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() { diff --git a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMatcherTest.java b/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMatcherTest.java index 7f0adc8..4614215 100644 --- a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMatcherTest.java +++ b/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() { diff --git a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMockTest.java b/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMockTest.java index 8e1e8d6..ddb4f11 100644 --- a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoMockTest.java +++ b/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()); diff --git a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoTemplateTest.java b/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoTemplateTest.java index 1bad58b..efbff5d 100644 --- a/demo/java-demo/src/test/java/com/alibaba/testable/demo/DemoTemplateTest.java +++ b/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 List getList(DemoTemplate self, T value) { - return new ArrayList() {{ add((T)(value.toString() + "_mock_list")); }}; + @MockMethod + private List getList(DemoTemplate self, T value) { + return new ArrayList() {{ add((T)(value.toString() + "_mock_list")); }}; + } + + @MockMethod + private Map getMap(DemoTemplate self, K key, V value) { + return new HashMap() {{ put(key, (V)(value.toString() + "_mock_map")); }}; + } + + @MockConstructor + private HashSet newHashSet() { + HashSet set = new HashSet<>(); + set.add((T)"insert_mock"); + return set; + } + + @MockMethod + private boolean add(Set s, E e) { + s.add(e.toString() + "_mocked"); + return true; + } + + /* 第二种写法：使用Object类型 */ + /* Second solution: use object type */ + + //@MockMethod + //private List getList(DemoTemplate self, Object value) { + // return new ArrayList() {{ add(value.toString() + "_mock_list"); }}; + //} + // + //@MockMethod + //private Map getMap(DemoTemplate self, Object key, Object value) { + // return new HashMap() {{ put(key, value.toString() + "_mock_map"); }}; + //} + // + //@MockConstructor + //private HashSet newHashSet() { + // HashSet 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 Map getMap(DemoTemplate self, K key, V value) { - return new HashMap() {{ put(key, (V)(value.toString() + "_mock_map")); }}; - } - - @MockConstructor - private HashSet newHashSet() { - HashSet set = new HashSet<>(); - set.add((T)"insert_mock"); - return set; - } - - @MockMethod - private boolean add(Set s, E e) { - s.add(e.toString() + "_mocked"); - return true; - } - - /* 第二种写法：使用Object类型 */ - /* Second solution: use object type */ - - //@MockMethod - //private static List getList(DemoTemplate self, Object value) { - // return new ArrayList() {{ add(value.toString() + "_mock_list"); }}; - //} - // - //@MockMethod - //private static Map getMap(DemoTemplate self, Object key, Object value) { - // return new HashMap() {{ put(key, value.toString() + "_mock_map"); }}; - //} - // - //@MockConstructor - //private HashSet newHashSet() { - // HashSet 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(); diff --git a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoInheritTest.kt b/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoInheritTest.kt index a4a6a13..28b8f5f 100644 --- a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoInheritTest.kt +++ b/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 diff --git a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoMatcherTest.kt b/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoMatcherTest.kt index 3919a1b..b295c86 100644 --- a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoMatcherTest.kt +++ b/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) { + @MockMethod(targetMethod = "methodToBeMocked") + private fun methodWithArrayArgument(self: DemoMatcher, a: Array) { + } } - @Test fun should_match_no_argument() { demoMatcher.callMethodWithoutArgument() diff --git a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoMockTest.kt b/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoMockTest.kt index ee8aec8..410b5ed 100644 --- a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoMockTest.kt +++ b/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()) diff --git a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoTemplateTest.kt b/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoTemplateTest.kt index 608a0c3..250b609 100644 --- a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/DemoTemplateTest.kt +++ b/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 getList(self: DemoTemplate, value: T): List { - return mutableListOf((value.toString() + "_mock_list") as T) - } + class Mock { + @MockMethod + private fun getList(self: DemoTemplate, value: T): List { + return mutableListOf((value.toString() + "_mock_list") as T) + } - @MockMethod - private fun getMap(self: DemoTemplate, key: K, value: V): Map { - return mutableMapOf(key to (value.toString() + "_mock_map") as V) - } + @MockMethod + private fun getMap(self: DemoTemplate, key: K, value: V): Map { + return mutableMapOf(key to (value.toString() + "_mock_map") as V) + } - @MockConstructor - private fun newHashSet(): HashSet<*> { - val set = HashSet() - set.add("insert_mock") - return set - } + @MockConstructor + private fun newHashSet(): HashSet<*> { + val set = HashSet() + set.add("insert_mock") + return set + } - @MockMethod - private fun add(s: MutableSet, e: E): Boolean { - s.add((e.toString() + "_mocked") as E) - return true + @MockMethod + private fun add(s: MutableSet, 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() diff --git a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/util/PathUtilTest.kt b/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/util/PathUtilTest.kt index 10597ef..fcc218c 100644 --- a/demo/kotlin-demo/src/test/kotlin/com/alibaba/testable/demo/util/PathUtilTest.kt +++ b/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? { - 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? { + 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() + } } }