From 9c757cebc1090d9f79ce83f122094de7ee068a56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=87=91=E6=88=9F?= Date: Wed, 22 Jul 2020 23:26:03 +0800 Subject: [PATCH] unfold parameter list for n.e.f method --- .../com/alibaba/testable/util/TypeUtil.java | 32 +++++------ core/src/main/java/n/e.java | 57 +++++++++++++++++++ 2 files changed, 73 insertions(+), 16 deletions(-) diff --git a/core/src/main/java/com/alibaba/testable/util/TypeUtil.java b/core/src/main/java/com/alibaba/testable/util/TypeUtil.java index ff28cce..9cf78fd 100644 --- a/core/src/main/java/com/alibaba/testable/util/TypeUtil.java +++ b/core/src/main/java/com/alibaba/testable/util/TypeUtil.java @@ -33,38 +33,38 @@ public class TypeUtil { /** * add item to constructor pool */ - public static void addToConstructorPool(TestableSubstitution np) { - mockNewPool.add(np); + public static void addToConstructorPool(TestableSubstitution substitution) { + mockNewPool.add(substitution); } /** * add item to method pool */ - public static void addToMemberMethodPool(TestableSubstitution np) { - mockMemberPool.add(np); + public static void addToMemberMethodPool(TestableSubstitution substitution) { + mockMemberPool.add(substitution); } /** * substitution entry for new */ - public static T wrapNew(Class ct, Object... as) { - Class[] cs = TypeUtil.getClassesFromObjects(as); + public static T wrapNew(Class classType, Object... parameters) { + Class[] cs = TypeUtil.getClassesFromObjects(parameters); if (!mockNewPool.isEmpty()) { try { - TestableSubstitution pi = getFromConstructorPool(ct, cs); + TestableSubstitution pi = getFromConstructorPool(classType, cs); if (pi != null) { Method m = pi.targetObject.getClass().getDeclaredMethod(pi.methodName, pi.parameterTypes); m.setAccessible(true); - return (T)m.invoke(pi.targetObject, as); + return (T)m.invoke(pi.targetObject, parameters); } } catch (Exception e) { return null; } } try { - Constructor c = TypeUtil.getConstructorByParameterTypes(ct.getConstructors(), cs); + Constructor c = TypeUtil.getConstructorByParameterTypes(classType.getConstructors(), cs); if (c != null) { - return (T)c.newInstance(as); + return (T)c.newInstance(parameters); } } catch (Exception e) { return null; @@ -75,25 +75,25 @@ public class TypeUtil { /** * substitution entry for member call */ - public static T wrapCall(Object obj, String mn, Object... as) { - Class[] cs = TypeUtil.getClassesFromObjects(as); + public static T wrapCall(Object targetObject, String methodName, Object... parameters) { + Class[] cs = TypeUtil.getClassesFromObjects(parameters); if (!mockMemberPool.isEmpty()) { try { - TestableSubstitution pi = getFromMemberMethodPool(mn, cs); + TestableSubstitution pi = getFromMemberMethodPool(methodName, cs); if (pi != null) { Method m = pi.targetObject.getClass().getDeclaredMethod(pi.methodName, pi.parameterTypes); m.setAccessible(true); - return (T)m.invoke(pi.targetObject, as); + return (T)m.invoke(pi.targetObject, parameters); } } catch (Exception e) { return null; } } try { - Method m = TypeUtil.getMethodByNameAndParameterTypes(obj.getClass().getDeclaredMethods(), mn, cs); + Method m = TypeUtil.getMethodByNameAndParameterTypes(targetObject.getClass().getDeclaredMethods(), methodName, cs); if (m != null) { m.setAccessible(true); - return (T)m.invoke(obj, as); + return (T)m.invoke(targetObject, parameters); } } catch (Exception e) { return null; diff --git a/core/src/main/java/n/e.java b/core/src/main/java/n/e.java index 90bafff..d4d6dfa 100644 --- a/core/src/main/java/n/e.java +++ b/core/src/main/java/n/e.java @@ -1,5 +1,6 @@ package n; +import static com.alibaba.testable.util.TypeUtil.wrapCall; import static com.alibaba.testable.util.TypeUtil.wrapNew; public final class e { @@ -61,4 +62,60 @@ public final class e { return wrapNew(ct, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); } + public static T f(Object o, String mn) { + return wrapCall(o, mn); + } + + public static T f(Object o, String mn, Object a1) { + return wrapCall(o, mn, a1); + } + + public static T f(Object o, String mn, Object a1, Object a2) { + return wrapCall(o, mn, a1, a2); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3) { + return wrapCall(o, mn, a1, a2, a3); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4) { + return wrapCall(o, mn, a1, a2, a3, a4); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5) { + return wrapCall(o, mn, a1, a2, a3, a4, a5); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6, a7); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, + Object a8) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6, a7, a8); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, + Object a8, Object a9) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, + Object a8, Object a9, Object a10) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, + Object a8, Object a9, Object a10, Object a11) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } + + public static T f(Object o, String mn, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, + Object a8, Object a9, Object a10, Object a11, Object a12) { + return wrapCall(o, mn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } }