github-repos/testable-mock
1
0
Fork 0
mirror of https://github.com/alibaba/testable-mock.git synced 2025-04-02 15:40:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

in favor of static import

Browse Source
This commit is contained in:
金戟 2021-06-06 23:04:42 +08:00
parent 0551240c7d
commit b949f57d54
8 changed files with 88 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
demo/java-demo/src/test/java/com/alibaba/demo/basic/DemoPrivateAccessorTest.java
View File

@ -1,11 +1,11 @@
package com.alibaba.demo.basic; package com.alibaba.demo.basic;
import com.alibaba.testable.core.tool.PrivateAccessor;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import static com.alibaba.testable.core.tool.PrivateAccessor.*;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
@ -20,39 +20,39 @@ class DemoPrivateAccessorTest {
@Test @Test
void should_access_private_method() { void should_access_private_method() {
List<String> list = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }}; List<String> list = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }};
assertEquals("member", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc")); assertEquals("member", invoke(demoPrivateAccess, "privateFunc"));
assertEquals("abc + hello + 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFuncWithArgs", list, "hello", 1)); assertEquals("abc + hello + 1", invoke(demoPrivateAccess, "privateFuncWithArgs", list, "hello", 1));
} }
@Test @Test
void should_access_private_field() { void should_access_private_field() {
PrivateAccessor.set(demoPrivateAccess, "count", 3); set(demoPrivateAccess, "count", 3);
assertEquals(Integer.valueOf(3), PrivateAccessor.get(demoPrivateAccess, "count")); assertEquals(Integer.valueOf(3), get(demoPrivateAccess, "count"));
} }
@Test @Test
void should_access_private_static_method() { void should_access_private_static_method() {
assertEquals("static", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFunc")); assertEquals("static", invokeStatic(DemoPrivateAccess.class, "privateStaticFunc"));
assertEquals("hello + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", "hello", 1)); assertEquals("hello + 1", invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", "hello", 1));
} }
@Test @Test
void should_access_private_static_field() { void should_access_private_static_field() {
PrivateAccessor.setStatic(DemoPrivateAccess.class, "staticCount", 3); setStatic(DemoPrivateAccess.class, "staticCount", 3);
assertEquals(Integer.valueOf(3), PrivateAccessor.getStatic(DemoPrivateAccess.class, "staticCount")); assertEquals(Integer.valueOf(3), getStatic(DemoPrivateAccess.class, "staticCount"));
} }
@Test @Test
void should_update_final_field() { void should_update_final_field() {
PrivateAccessor.set(demoPrivateAccess, "pi", 3.14); set(demoPrivateAccess, "pi", 3.14);
assertEquals(Double.valueOf(3.14), PrivateAccessor.get(demoPrivateAccess, "pi")); assertEquals(Double.valueOf(3.14), get(demoPrivateAccess, "pi"));
} }
@Test @Test
void should_use_null_parameter() { void should_use_null_parameter() {
PrivateAccessor.set(demoPrivateAccess, "pi", null); set(demoPrivateAccess, "pi", null);
assertNull(PrivateAccessor.get(demoPrivateAccess, "pi")); assertNull(get(demoPrivateAccess, "pi"));
assertEquals("null + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", null, 1)); assertEquals("null + 1", invokeStatic(DemoPrivateAccess.class, "privateStaticFuncWithArgs", null, 1));
} }
} }

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

@ -1,6 +1,6 @@
package com.alibaba.demo.basic package com.alibaba.demo.basic
import com.alibaba.testable.core.tool.PrivateAccessor import com.alibaba.testable.core.tool.PrivateAccessor.*
import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test import org.junit.jupiter.api.Test
@ -15,31 +15,31 @@ internal class DemoPrivateAccessorTest {
@Test @Test
fun should_access_private_method() { fun should_access_private_method() {
val list = listOf("a", "b", "c"); val list = listOf("a", "b", "c");
assertEquals("abc + hello + 1", PrivateAccessor.invoke(demoPrivateAccess, "privateFunc", list, "hello", 1)) assertEquals("abc + hello + 1", invoke(demoPrivateAccess, "privateFunc", list, "hello", 1))
} }
@Test @Test
fun should_access_private_field() { fun should_access_private_field() {
PrivateAccessor.set(demoPrivateAccess, "count", 3) set(demoPrivateAccess, "count", 3)
assertEquals(3, PrivateAccessor.get(demoPrivateAccess, "count")) assertEquals(3, get(demoPrivateAccess, "count"))
} }
@Test @Test
fun should_access_private_static_method() { fun should_access_private_static_method() {
val list = listOf("a", "b", "c"); val list = listOf("a", "b", "c");
assertEquals("hello + 1", PrivateAccessor.invokeStatic(DemoPrivateAccess::class.java, "privateStaticFunc", "hello", 1)) assertEquals("hello + 1", invokeStatic(DemoPrivateAccess::class.java, "privateStaticFunc", "hello", 1))
assertEquals("abc * hello * 1", PrivateAccessor.invokeStatic(DemoPrivateAccess::class.java, "privateJvmStaticFunc", list, "hello", 1)) assertEquals("abc * hello * 1", invokeStatic(DemoPrivateAccess::class.java, "privateJvmStaticFunc", list, "hello", 1))
} }
@Test @Test
fun should_access_private_static_field() { fun should_access_private_static_field() {
PrivateAccessor.setStatic(DemoPrivateAccess::class.java, "staticCount", 3) setStatic(DemoPrivateAccess::class.java, "staticCount", 3)
assertEquals(3, PrivateAccessor.getStatic(DemoPrivateAccess::class.java, "staticCount")) assertEquals(3, getStatic(DemoPrivateAccess::class.java, "staticCount"))
} }
@Test @Test
fun should_update_final_field() { fun should_update_final_field() {
PrivateAccessor.set(demoPrivateAccess, "pi", 4.13) set(demoPrivateAccess, "pi", 4.13)
assertEquals(4.13, demoPrivateAccess.pi) assertEquals(4.13, demoPrivateAccess.pi)
} }

8
testable-agent/src/test/java/com/alibaba/testable/agent/handler/SourceClassHandlerTest.java
View File

@ -1,7 +1,6 @@
package com.alibaba.testable.agent.handler; package com.alibaba.testable.agent.handler;
import com.alibaba.testable.agent.model.MethodInfo; import com.alibaba.testable.agent.model.MethodInfo;
import com.alibaba.testable.core.tool.PrivateAccessor;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnNode; import org.objectweb.asm.tree.InsnNode;
@ -10,6 +9,7 @@ import org.objectweb.asm.tree.VarInsnNode;
import java.util.ArrayList; import java.util.ArrayList;
import static com.alibaba.testable.core.tool.PrivateAccessor.invoke;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
import static org.objectweb.asm.Opcodes.*; import static org.objectweb.asm.Opcodes.*;
@ -31,8 +31,8 @@ class SourceClassHandlerTest {
new MethodInsnNode(INVOKEVIRTUAL, "com/alibaba/testable/demo/BlackBox", "callMe", "()Ljava/lang/String;", false), new MethodInsnNode(INVOKEVIRTUAL, "com/alibaba/testable/demo/BlackBox", "callMe", "()Ljava/lang/String;", false),
new MethodInsnNode(INVOKEVIRTUAL, "java/lang/String", "startsWith", "(Ljava/lang/String;)Z", false) new MethodInsnNode(INVOKEVIRTUAL, "java/lang/String", "startsWith", "(Ljava/lang/String;)Z", false)
}; };
assertEquals(2, PrivateAccessor.invoke(handler, "getMemberMethodStart", instructions, 3)); assertEquals(2, invoke(handler, "getMemberMethodStart", instructions, 3));
assertEquals(2, PrivateAccessor.invoke(handler, "getMemberMethodStart", instructions, 6)); assertEquals(2, invoke(handler, "getMemberMethodStart", instructions, 6));
assertEquals(0, PrivateAccessor.invoke(handler, "getMemberMethodStart", instructions, 9)); assertEquals(0, invoke(handler, "getMemberMethodStart", instructions, 9));
} }
} }

17
testable-agent/src/test/java/com/alibaba/testable/agent/util/MethodUtilTest.java
View File

@ -1,11 +1,12 @@
package com.alibaba.testable.agent.util; package com.alibaba.testable.agent.util;
import com.alibaba.testable.agent.tool.ImmutablePair; import com.alibaba.testable.agent.tool.ImmutablePair;
import com.alibaba.testable.core.tool.PrivateAccessor;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable; import org.junit.jupiter.api.function.Executable;
import static org.junit.jupiter.api.Assertions.*; import static com.alibaba.testable.core.tool.PrivateAccessor.invokeStatic;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
class MethodUtilTest { class MethodUtilTest {
@ -67,12 +68,12 @@ class MethodUtilTest {
@Test @Test
void should_convert_bytecode_parameters() { void should_convert_bytecode_parameters() {
assertEquals("", PrivateAccessor.invokeStatic(MethodUtil.class, "toJavaParameterDesc", "")); assertEquals("", invokeStatic(MethodUtil.class, "toJavaParameterDesc", ""));
assertEquals("void", PrivateAccessor.invokeStatic(MethodUtil.class, "toJavaParameterDesc", "V")); assertEquals("void", invokeStatic(MethodUtil.class, "toJavaParameterDesc", "V"));
assertEquals("int, long", PrivateAccessor.invokeStatic(MethodUtil.class, "toJavaParameterDesc", "IJ")); assertEquals("int, long", invokeStatic(MethodUtil.class, "toJavaParameterDesc", "IJ"));
assertEquals("int[], long[]", PrivateAccessor.invokeStatic(MethodUtil.class, "toJavaParameterDesc", "[I[J")); assertEquals("int[], long[]", invokeStatic(MethodUtil.class, "toJavaParameterDesc", "[I[J"));
assertEquals("int, java.lang.String", PrivateAccessor.invokeStatic(MethodUtil.class, "toJavaParameterDesc", "ILjava/lang/String;")); assertEquals("int, java.lang.String", invokeStatic(MethodUtil.class, "toJavaParameterDesc", "ILjava/lang/String;"));
assertEquals("java.lang.String, int, long[]", PrivateAccessor.invokeStatic(MethodUtil.class, "toJavaParameterDesc", "Ljava/lang/String;I[J")); assertEquals("java.lang.String, int, long[]", invokeStatic(MethodUtil.class, "toJavaParameterDesc", "Ljava/lang/String;I[J"));
} }
} }

8
testable-core/src/main/java/com/alibaba/testable/core/util/MockAssociationUtil.java
View File

@ -1,6 +1,5 @@
package com.alibaba.testable.core.util; package com.alibaba.testable.core.util;
import com.alibaba.testable.core.tool.PrivateAccessor;
import com.alibaba.testable.core.model.MockContext; import com.alibaba.testable.core.model.MockContext;
import java.util.HashSet; import java.util.HashSet;
@ -8,6 +7,7 @@ import java.util.Map;
import java.util.Set; import java.util.Set;
import static com.alibaba.testable.core.constant.ConstPool.*; import static com.alibaba.testable.core.constant.ConstPool.*;
import static com.alibaba.testable.core.tool.PrivateAccessor.*;
public class MockAssociationUtil { public class MockAssociationUtil {
@ -67,11 +67,11 @@ public class MockAssociationUtil {
*/ */
public static Object invokeOrigin(Class<?> originClass, String originMethod, Object... args) { public static Object invokeOrigin(Class<?> originClass, String originMethod, Object... args) {
if (originMethod.equals(CONSTRUCTOR)) { if (originMethod.equals(CONSTRUCTOR)) {
return PrivateAccessor.construct(originClass, args); return construct(originClass, args);
} else if (args[0] == null) { } else if (args[0] == null) {
return PrivateAccessor.invokeStatic(originClass, originMethod, CollectionUtil.slice(args, 1)); return invokeStatic(originClass, originMethod, CollectionUtil.slice(args, 1));
} else { } else {
return PrivateAccessor.invoke(args[0], originMethod, CollectionUtil.slice(args, 1)); return invoke(args[0], originMethod, CollectionUtil.slice(args, 1));
} }
} }

77
testable-core/src/test/java/com/alibaba/testable/core/tool/OmniAccessorTest.java
View File

@ -4,13 +4,14 @@ import org.junit.jupiter.api.Test;
import java.util.List; import java.util.List;
import static com.alibaba.testable.core.tool.PrivateAccessor.*;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
class OmniAccessorTest { class OmniAccessorTest {
@Test @Test
void should_generate_member_index() { void should_generate_member_index() {
List<String> index = PrivateAccessor.invokeStatic(OmniAccessor.class, "generateMemberIndex", DemoParent.class); List<String> index = invokeStatic(OmniAccessor.class, "generateMemberIndex", DemoParent.class);
assertEquals(34, index.size()); assertEquals(34, index.size());
assertEquals("/c{DemoChild}", index.get(0)); assertEquals("/c{DemoChild}", index.get(0));
assertEquals("/c{DemoChild}/gc{DemoGrandChild}", index.get(1)); assertEquals("/c{DemoChild}/gc{DemoGrandChild}", index.get(1));
@ -50,48 +51,48 @@ class OmniAccessorTest {
@Test @Test
void should_to_pattern() { void should_to_pattern() {
assertEquals(".*/", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "")); assertEquals(".*/", invokeStatic(OmniAccessor.class, "toPattern", ""));
assertEquals(".*/abc\\{[^}]+\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc")); assertEquals(".*/abc\\{[^}]+\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc"));
assertEquals(".*/[^{]+\\{Abc\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "{Abc}")); assertEquals(".*/[^{]+\\{Abc\\}", invokeStatic(OmniAccessor.class, "toPattern", "{Abc}"));
assertEquals(".*/abc\\{[^}]+\\}/xyz\\{[^}]+\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/xyz")); assertEquals(".*/abc\\{[^}]+\\}/xyz\\{[^}]+\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/xyz"));
assertEquals(".*/[^{]+\\{Abc\\}/xyz\\{[^}]+\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "{Abc}/xyz")); assertEquals(".*/[^{]+\\{Abc\\}/xyz\\{[^}]+\\}", invokeStatic(OmniAccessor.class, "toPattern", "{Abc}/xyz"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/{Xyz}"));
assertEquals(".*/[^{]+\\{Abc\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "{Abc}/{Xyz}")); assertEquals(".*/[^{]+\\{Abc\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "{Abc}/{Xyz}"));
assertEquals(".*/[^{]+\\{Abc\\[\\]\\}/[^{]+\\{Xyz\\[\\]\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "{Abc[]}/{Xyz[]}")); assertEquals(".*/[^{]+\\{Abc\\[\\]\\}/[^{]+\\{Xyz\\[\\]\\}", invokeStatic(OmniAccessor.class, "toPattern", "{Abc[]}/{Xyz[]}"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{Xyz\\[\\]\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc[1]/{Xyz[]}[2]")); assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{Xyz\\[\\]\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc[1]/{Xyz[]}[2]"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{Xyz\\}/demo\\{[^}]+\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/{Xyz}/demo")); assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{Xyz\\}/demo\\{[^}]+\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/{Xyz}/demo"));
assertEquals(".*/abc\\{[^}]+\\}/de[^{]*\\{[^}]+\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/de*/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/de[^{]*\\{[^}]+\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/de*/{Xyz}"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]*mo\\{[^}]+\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/*mo/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/[^{]*mo\\{[^}]+\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/*mo/{Xyz}"));
assertEquals(".*/abc\\{[^}]+\\}/d[^{]*o\\{[^}]+\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/d*o/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/d[^{]*o\\{[^}]+\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/d*o/{Xyz}"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{De[^}]*\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/{De*}/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{De[^}]*\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/{De*}/{Xyz}"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{[^}]*mo\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/{*mo}/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{[^}]*mo\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/{*mo}/{Xyz}"));
assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{D[^}]*o\\}/[^{]+\\{Xyz\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/{D*o}/{Xyz}")); assertEquals(".*/abc\\{[^}]+\\}/[^{]+\\{D[^}]*o\\}/[^{]+\\{Xyz\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/{D*o}/{Xyz}"));
assertEquals(".*/abc\\{[^}]+\\}/[^/]+/[^{]+\\{Xyz\\}/[^/]+/demo\\{[^}]+\\}", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toPattern", "abc/*/{Xyz}/*/demo")); assertEquals(".*/abc\\{[^}]+\\}/[^/]+/[^{]+\\{Xyz\\}/[^/]+/demo\\{[^}]+\\}", invokeStatic(OmniAccessor.class, "toPattern", "abc/*/{Xyz}/*/demo"));
} }
@Test @Test
void should_to_parent() { void should_to_parent() {
assertEquals("", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toParent", "")); assertEquals("", invokeStatic(OmniAccessor.class, "toParent", ""));
assertEquals("", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toParent", "abc")); assertEquals("", invokeStatic(OmniAccessor.class, "toParent", "abc"));
assertEquals("abc", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toParent", "abc/xyz")); assertEquals("abc", invokeStatic(OmniAccessor.class, "toParent", "abc/xyz"));
assertEquals("abc/def", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toParent", "abc/def/xyz")); assertEquals("abc/def", invokeStatic(OmniAccessor.class, "toParent", "abc/def/xyz"));
assertEquals("/abc/def", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toParent", "/abc/def/xyz")); assertEquals("/abc/def", invokeStatic(OmniAccessor.class, "toParent", "/abc/def/xyz"));
} }
@Test @Test
void should_to_child() { void should_to_child() {
assertEquals("", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toChild", "")); assertEquals("", invokeStatic(OmniAccessor.class, "toChild", ""));
assertEquals("abc", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toChild", "abc")); assertEquals("abc", invokeStatic(OmniAccessor.class, "toChild", "abc"));
assertEquals("xyz", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toChild", "abc/xyz")); assertEquals("xyz", invokeStatic(OmniAccessor.class, "toChild", "abc/xyz"));
assertEquals("xyz", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toChild", "abc/def/xyz")); assertEquals("xyz", invokeStatic(OmniAccessor.class, "toChild", "abc/def/xyz"));
assertEquals("xyz", PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "toChild", "/abc/def/xyz")); assertEquals("xyz", invokeStatic(OmniAccessor.class, "toChild", "/abc/def/xyz"));
} }
@Test @Test
void should_get_full_query_segments() { void should_get_full_query_segments() {
String[] querySegments = new String[] { "c", "d" }; String[] querySegments = new String[] { "c", "d" };
String[] memberSegments = new String[] { "a{A}", "b{B}", "c{C}", "d{D}" }; String[] memberSegments = new String[] { "a{A}", "b{B}", "c{C}", "d{D}" };
String[] fullQuerySegments = PrivateAccessor.invokeStatic(OmniAccessor.class, "calculateFullQueryPath", querySegments, memberSegments); String[] fullQuerySegments = invokeStatic(OmniAccessor.class, "calculateFullQueryPath", querySegments, memberSegments);
assertEquals(5, fullQuerySegments.length); assertEquals(5, fullQuerySegments.length);
assertEquals("", fullQuerySegments[0]); assertEquals("", fullQuerySegments[0]);
assertEquals("", fullQuerySegments[1]); assertEquals("", fullQuerySegments[1]);
@ -103,18 +104,18 @@ class OmniAccessorTest {
@Test @Test
void should_get_by_path() { void should_get_by_path() {
DemoParent parent = prepareParentObject(); DemoParent parent = prepareParentObject();
List<Object> obj = PrivateAccessor.invokeStatic(OmniAccessor.class, "getByPath", parent, "/c{DemoChild}/gc{DemoGrandChild}", "c/gc"); List<Object> obj = invokeStatic(OmniAccessor.class, "getByPath", parent, "/c{DemoChild}/gc{DemoGrandChild}", "c/gc");
assertTrue(obj.get(0) instanceof DemoGrandChild); assertTrue(obj.get(0) instanceof DemoGrandChild);
assertEquals(1, ((DemoGrandChild)obj.get(0)).get()); assertEquals(1, ((DemoGrandChild)obj.get(0)).get());
PrivateAccessor.set(parent.c, "gcs", new DemoGrandChild[] { new DemoGrandChild(), new DemoGrandChild() }); set(parent.c, "gcs", new DemoGrandChild[] { new DemoGrandChild(), new DemoGrandChild() });
obj = PrivateAccessor.invokeStatic(OmniAccessor.class, "getByPath", parent, "/c{DemoChild}/gcs{DemoGrandChild[]}", "c/gcs"); obj = invokeStatic(OmniAccessor.class, "getByPath", parent, "/c{DemoChild}/gcs{DemoGrandChild[]}", "c/gcs");
assertTrue(obj.get(0) instanceof DemoGrandChild[]); assertTrue(obj.get(0) instanceof DemoGrandChild[]);
assertEquals(2, ((DemoGrandChild[])obj.get(0)).length); assertEquals(2, ((DemoGrandChild[])obj.get(0)).length);
obj = PrivateAccessor.invokeStatic(OmniAccessor.class, "getByPath", parent, "/c{DemoChild}/gcs{DemoGrandChild[]}", "c/gcs[1]"); obj = invokeStatic(OmniAccessor.class, "getByPath", parent, "/c{DemoChild}/gcs{DemoGrandChild[]}", "c/gcs[1]");
assertTrue(obj.get(0) instanceof DemoGrandChild); assertTrue(obj.get(0) instanceof DemoGrandChild);
assertEquals(1, ((DemoGrandChild)obj.get(0)).get()); assertEquals(1, ((DemoGrandChild)obj.get(0)).get());
parent.cs = new DemoChild[] { null, prepareChildObject() }; parent.cs = new DemoChild[] { null, prepareChildObject() };
obj = PrivateAccessor.invokeStatic(OmniAccessor.class, "getByPath", parent, "/cs{DemoChild[]}/gcs{DemoGrandChild[]}/i{int}", "c[1]/gcs[1]/i"); obj = invokeStatic(OmniAccessor.class, "getByPath", parent, "/cs{DemoChild[]}/gcs{DemoGrandChild[]}/i{int}", "c[1]/gcs[1]/i");
assertEquals(1, obj.get(0)); assertEquals(1, obj.get(0));
} }
@ -122,13 +123,13 @@ class OmniAccessorTest {
void should_set_by_path_segment() { void should_set_by_path_segment() {
DemoParent parent = prepareParentObject(); DemoParent parent = prepareParentObject();
DemoChild child = prepareChildObject(); DemoChild child = prepareChildObject();
PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "setByPathSegment", parent.c, "gc{DemoGrandChild}", "gc", new DemoGrandChild()); invokeStatic(OmniAccessor.class, "setByPathSegment", parent.c, "gc{DemoGrandChild}", "gc", new DemoGrandChild());
assertEquals(1, parent.c.gc.get()); assertEquals(1, parent.c.gc.get());
PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "setByPathSegment", parent, "cs{DemoChild[]}", "cs[2]", child); invokeStatic(OmniAccessor.class, "setByPathSegment", parent, "cs{DemoChild[]}", "cs[2]", child);
assertNull(parent.cs[0]); assertNull(parent.cs[0]);
assertNull(parent.cs[1]); assertNull(parent.cs[1]);
assertEquals(5, parent.cs[2].gc.get()); assertEquals(5, parent.cs[2].gc.get());
PrivateAccessor.<String>invokeStatic(OmniAccessor.class, "setByPathSegment", parent, "cs{DemoChild[]}", "cs", child); invokeStatic(OmniAccessor.class, "setByPathSegment", parent, "cs{DemoChild[]}", "cs", child);
assertEquals(5, parent.cs[0].gc.get()); assertEquals(5, parent.cs[0].gc.get());
assertEquals(5, parent.cs[1].gc.get()); assertEquals(5, parent.cs[1].gc.get());
assertEquals(5, parent.cs[2].gc.get()); assertEquals(5, parent.cs[2].gc.get());
@ -142,7 +143,7 @@ class OmniAccessorTest {
private DemoChild prepareChildObject() { private DemoChild prepareChildObject() {
DemoChild child = OmniConstructor.newInstance(DemoChild.class); DemoChild child = OmniConstructor.newInstance(DemoChild.class);
PrivateAccessor.set(child, "gcs", new DemoGrandChild[] { null, new DemoGrandChild() }); set(child, "gcs", new DemoGrandChild[] { null, new DemoGrandChild() });
child.gc.set(5); child.gc.set(5);
return child; return child;
} }

4
testable-core/src/test/java/com/alibaba/testable/core/util/CollectionUtilTest.java
View File

@ -1,8 +1,8 @@
package com.alibaba.testable.core.util; package com.alibaba.testable.core.util;
import com.alibaba.testable.core.tool.PrivateAccessor;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import static com.alibaba.testable.core.tool.PrivateAccessor.invokeStatic;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
class CollectionUtilTest { class CollectionUtilTest {
@ -10,7 +10,7 @@ class CollectionUtilTest {
@Test @Test
void should_slice_array() { void should_slice_array() {
Object[] args = new Object[]{"1", "2", "3"}; Object[] args = new Object[]{"1", "2", "3"};
Object[] slicedArgs = PrivateAccessor.invokeStatic(CollectionUtil.class, "slice", args, 1); Object[] slicedArgs = invokeStatic(CollectionUtil.class, "slice", args, 1);
assertEquals(2, slicedArgs.length); assertEquals(2, slicedArgs.length);
assertEquals("2", slicedArgs[0]); assertEquals("2", slicedArgs[0]);
assertEquals("3", slicedArgs[1]); assertEquals("3", slicedArgs[1]);

13
testable-core/src/test/java/com/alibaba/testable/core/util/MockAssociationUtilTest.java
View File

@ -1,25 +1,26 @@
package com.alibaba.testable.core.util; package com.alibaba.testable.core.util;
import com.alibaba.testable.core.tool.PrivateAccessor;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*; import static com.alibaba.testable.core.tool.PrivateAccessor.invokeStatic;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
class MockAssociationUtilTest { class MockAssociationUtilTest {
@Test @Test
void should_associate_by_inner_mock_class() { void should_associate_by_inner_mock_class() {
assertTrue((Boolean)PrivateAccessor.invokeStatic(MockAssociationUtil.class, "isAssociatedByInnerMockClass", assertTrue((Boolean)invokeStatic(MockAssociationUtil.class, "isAssociatedByInnerMockClass",
"com.alibaba.testable.DemoTest", "com.alibaba.testable.DemoTest$Mock")); "com.alibaba.testable.DemoTest", "com.alibaba.testable.DemoTest$Mock"));
assertFalse((Boolean)PrivateAccessor.invokeStatic(MockAssociationUtil.class, "isAssociatedByInnerMockClass", assertFalse((Boolean)invokeStatic(MockAssociationUtil.class, "isAssociatedByInnerMockClass",
"com.alibaba.testable.DemoTest", "com.alibaba.testable.DemoTestMock")); "com.alibaba.testable.DemoTest", "com.alibaba.testable.DemoTestMock"));
} }
@Test @Test
void should_associate_by_outer_mock_class() { void should_associate_by_outer_mock_class() {
assertTrue((Boolean)PrivateAccessor.invokeStatic(MockAssociationUtil.class, "isAssociatedByOuterMockClass", assertTrue((Boolean)invokeStatic(MockAssociationUtil.class, "isAssociatedByOuterMockClass",
"com.alibaba.testable.DemoTest", "com.alibaba.testable.DemoMock")); "com.alibaba.testable.DemoTest", "com.alibaba.testable.DemoMock"));
assertFalse((Boolean)PrivateAccessor.invokeStatic(MockAssociationUtil.class, "isAssociatedByOuterMockClass", assertFalse((Boolean)invokeStatic(MockAssociationUtil.class, "isAssociatedByOuterMockClass",
"com.alibaba.testable.DemoTester", "com.alibaba.testable.DemoMock")); "com.alibaba.testable.DemoTester", "com.alibaba.testable.DemoMock"));
} }