From ed2003990110672278825945a1259fd0f767ff40 Mon Sep 17 00:00:00 2001 From: Javier Godoy <11554739+javier-godoy@users.noreply.github.com> Date: Mon, 1 Dec 2025 15:25:26 -0300 Subject: [PATCH 1/2] feat: add support for private callable methods --- .../ClassInstrumentationUtil.java | 189 +++++++++++- ...ExtendsLegacyClientCallablePrivate__V.java | 5 + .../LegacyClientCallablePrivate_D__V.java | 9 + .../LegacyClientCallablePrivate_I__V.java | 9 + ...acyClientCallablePrivate_JsonArray__V.java | 11 + ...yClientCallablePrivate_JsonBoolean__V.java | 11 + ...gacyClientCallablePrivate_JsonNull__V.java | 11 + ...cyClientCallablePrivate_JsonNumber__V.java | 11 + ...cyClientCallablePrivate_JsonObject__V.java | 11 + ...cyClientCallablePrivate_JsonString__V.java | 11 + ...acyClientCallablePrivate_JsonValue__V.java | 11 + ...LegacyClientCallablePrivate_String__V.java | 9 + .../LegacyClientCallablePrivate_Z__V.java | 9 + .../LegacyClientCallablePrivate__D.java | 10 + .../LegacyClientCallablePrivate__I.java | 10 + .../LegacyClientCallablePrivate__Integer.java | 10 + ...egacyClientCallablePrivate__JsonArray.java | 13 + ...acyClientCallablePrivate__JsonBoolean.java | 13 + ...LegacyClientCallablePrivate__JsonNull.java | 13 + ...gacyClientCallablePrivate__JsonNumber.java | 13 + ...gacyClientCallablePrivate__JsonObject.java | 13 + ...gacyClientCallablePrivate__JsonString.java | 13 + ...egacyClientCallablePrivate__JsonValue.java | 13 + .../LegacyClientCallablePrivate__V.java | 9 + .../LegacyClientCallablePrivate__Z.java | 10 + .../LegacyClientCallablesPrivateTest.java | 282 ++++++++++++++++++ .../LegacyClientCallablesPrivateTest24.java | 44 +++ .../LegacyClientCallablesPrivateTest25.java | 50 ++++ 28 files changed, 812 insertions(+), 11 deletions(-) create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/ExtendsLegacyClientCallablePrivate__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_D__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_I__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonArray__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonBoolean__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNull__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNumber__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonObject__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonString__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonValue__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_String__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_Z__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__D.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__I.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Integer.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonArray.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonBoolean.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNull.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNumber.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonObject.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonString.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonValue.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__V.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Z.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest24.java create mode 100644 src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest25.java diff --git a/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java b/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java index 82a9153..f6dad70 100644 --- a/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java +++ b/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java @@ -28,6 +28,9 @@ import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.WeakHashMap; @@ -149,10 +152,10 @@ private boolean hasLegacyVaadin() { return version <= 24; } - private static Stream getDeclaredCallables(Class parent) { - return Stream.of(parent.getDeclaredMethods()).filter(method -> { + private static Stream getDeclaredCallables(Class clazz) { + return Stream.of(clazz.getDeclaredMethods()).filter(method -> { int modifiers = method.getModifiers(); - if (!Modifier.isStatic(modifiers) && !Modifier.isPrivate(modifiers)) { + if (!Modifier.isStatic(modifiers)) { boolean isCallable = method.isAnnotationPresent(ClientCallable.class); boolean isLegacyCallable = method.isAnnotationPresent(LegacyClientCallable.class); return isCallable || isLegacyCallable; @@ -161,8 +164,27 @@ private static Stream getDeclaredCallables(Class parent) { }); } + private static Stream getAllCallables(Class baseClass) { + Map map = new HashMap<>(); + for (Class clazz = baseClass; clazz != Component.class; clazz = clazz.getSuperclass()) { + getDeclaredCallables(clazz).forEach(method -> { + Method existing = map.get(method.getName()); + if (existing == null) { + map.put(method.getName(), method); + } else if (!Arrays.equals(existing.getParameterTypes(), method.getParameterTypes())) { + String msg = String.format("There may be only one handler method with the given name. " + + "Class '%s' (considering its superclasses) " + + "contains several handler methods with the same name: '%s'", + baseClass.getName(), method.getName()); + throw new IllegalStateException(msg); + } + }); + } + return map.values().stream(); + } + private List getInstrumentableMethods(Class parent) { - return getDeclaredCallables(parent).filter(method -> { + return getAllCallables(parent).filter(method -> { boolean isCallable = method.isAnnotationPresent(ClientCallable.class); boolean isLegacyCallable = method.isAnnotationPresent(LegacyClientCallable.class); boolean hasJsonValueReturn = JsonValue.class.isAssignableFrom(method.getReturnType()); @@ -238,7 +260,7 @@ private byte[] generateBytecode(String className, Class parent) { cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, internalClassName, null, internalParentName, null); generateConstructor(cw, internalParentName); - generateClientCallableOverrides(cw, parent, internalParentName); + generateClientCallableOverrides(cw, parent, internalClassName, internalParentName); cw.visitEnd(); return cw.toByteArray(); @@ -255,13 +277,99 @@ private void generateConstructor(ClassWriter cw, String internalParentName) { } private void generateClientCallableOverrides(ClassWriter cw, Class parent, - String internalParentName) { + String internalClassName, String internalParentName) { + List privateMethodNames = new ArrayList<>(); for (Method method : getInstrumentableMethods(parent)) { - generateMethodOverride(cw, method, internalParentName); + if (Modifier.isPrivate(method.getModifiers())) { + privateMethodNames.add(method.getName()); + createLookupHelper(cw, method); + cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, + method.getName(), + Type.getDescriptor(MethodHandle.class), null, null); + } + generateMethodOverride(cw, method, internalClassName, internalParentName); } + + if (!privateMethodNames.isEmpty()) { + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_STATIC, "", "()V", null, null); + mv.visitCode(); + for (String name : privateMethodNames) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, + internalClassName, + "lookup_"+name, + "()"+Type.getDescriptor(MethodHandle.class), + false); + mv.visitFieldInsn(Opcodes.PUTSTATIC, + internalClassName, name, + "Ljava/lang/invoke/MethodHandle;"); + } + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + } + + private void createLookupHelper(ClassWriter cw, Method method) { + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, + "lookup_" + method.getName(), "()" + Type.getDescriptor(MethodHandle.class), null, null); + + // Invoke static MethodHandles.lookup() + mv.visitMethodInsn(Opcodes.INVOKESTATIC, + "java/lang/invoke/MethodHandles", + "lookup", + "()Ljava/lang/invoke/MethodHandles$Lookup;", + false); + + // Load the Owner class + mv.visitLdcInsn(Type.getType(method.getDeclaringClass())); + + // Load the Method Name + mv.visitLdcInsn(method.getName()); + + // Create Class[] array + Class argTypes[] = method.getParameterTypes(); + pushInt(mv, (short) argTypes.length); + mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Class"); + + // Load the specific Class objects and store in array + for (short i = 0; i < argTypes.length; i++) { + mv.visitInsn(Opcodes.DUP); + pushInt(mv, i); + loadClassConstant(mv, argTypes[i]); + mv.visitInsn(Opcodes.AASTORE); + } + + // Invoke getDeclaredMethod + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, + "java/lang/Class", + "getDeclaredMethod", + "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;", + false); + + // Invoke method.setAccessible(true) + mv.visitInsn(Opcodes.DUP); + mv.visitInsn(Opcodes.ICONST_1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, + "java/lang/reflect/Method", + "setAccessible", + "(Z)V", + false); + + // Invoke Lookup.unresolve(method) + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, + "java/lang/invoke/MethodHandles$Lookup", + "unreflect", + "(Ljava/lang/reflect/Method;)Ljava/lang/invoke/MethodHandle;", + false); + + // Return result + mv.visitInsn(Opcodes.ARETURN); + + mv.visitMaxs(0, 0); + mv.visitEnd(); } - private void generateMethodOverride(ClassWriter cw, Method method, String internalParentName) { + private void generateMethodOverride(ClassWriter cw, Method method, String internalClassName, String internalParentName) { boolean hasJsonValueReturn = !hasLegacyVaadin() && JsonValue.class.isAssignableFrom(method.getReturnType()); boolean hasJsonValueParams = !hasLegacyVaadin() && hasJsonValueParameters(method); @@ -275,6 +383,14 @@ private void generateMethodOverride(ClassWriter cw, Method method, String intern mv.visitAnnotation(Type.getDescriptor(ClientCallable.class), true); mv.visitCode(); + boolean isPrivate = Modifier.isPrivate(method.getModifiers()); + if (isPrivate) { + // Load MethodHandle from static field + mv.visitFieldInsn(Opcodes.GETSTATIC, + internalClassName, method.getName(), + "Ljava/lang/invoke/MethodHandle;"); + } + // Load 'this' mv.visitVarInsn(Opcodes.ALOAD, 0); @@ -301,9 +417,24 @@ private void generateMethodOverride(ClassWriter cw, Method method, String intern } } - // Call super.methodName(params) with original descriptor - mv.visitMethodInsn(Opcodes.INVOKESPECIAL, internalParentName, method.getName(), superDescriptor, - false); + if (isPrivate) { + // Call private method + String descriptor = + "(" + Type.getDescriptor(method.getDeclaringClass()) + + superDescriptor.substring(1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, + "java/lang/invoke/MethodHandle", + "invokeExact", + descriptor, + false); + } else { + // Call super.methodName(params) with original descriptor + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, + internalParentName, + method.getName(), + superDescriptor, + false); + } if (hasJsonValueReturn) { // Store result in local variable @@ -339,6 +470,42 @@ private void generateMethodOverride(ClassWriter cw, Method method, String intern mv.visitEnd(); } + private void pushInt(MethodVisitor mv, short value) { + if (value >= -1 && value <= 5) { + mv.visitInsn(Opcodes.ICONST_0 + value); + } else if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) { + mv.visitIntInsn(Opcodes.BIPUSH, value); + } else { + mv.visitIntInsn(Opcodes.SIPUSH, value); + } + } + + private void loadClassConstant(MethodVisitor mv, Class clazz) { + if (clazz.isPrimitive()) { + if (clazz == int.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Integer", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == boolean.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == byte.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Byte", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == char.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Character", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == short.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Short", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == float.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Float", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == long.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Long", "TYPE", "Ljava/lang/Class;"); + } else if (clazz == double.class) { + mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Double", "TYPE", "Ljava/lang/Class;"); + } else { + throw new IllegalArgumentException("Unsupported type: " + clazz); + } + } else { + mv.visitLdcInsn(Type.getType(clazz)); + } + } + private int loadParameter(MethodVisitor mv, Class paramType, int localVarIndex) { if (!paramType.isPrimitive()) { mv.visitVarInsn(Opcodes.ALOAD, localVarIndex); diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/ExtendsLegacyClientCallablePrivate__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/ExtendsLegacyClientCallablePrivate__V.java new file mode 100644 index 0000000..6400df3 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/ExtendsLegacyClientCallablePrivate__V.java @@ -0,0 +1,5 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class ExtendsLegacyClientCallablePrivate__V extends LegacyClientCallablePrivate__V { + +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_D__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_D__V.java new file mode 100644 index 0000000..f44f452 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_D__V.java @@ -0,0 +1,9 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate_D__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(double arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_I__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_I__V.java new file mode 100644 index 0000000..896e3b0 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_I__V.java @@ -0,0 +1,9 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate_I__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(int arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonArray__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonArray__V.java new file mode 100644 index 0000000..2fa0868 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonArray__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonArray; + +public class LegacyClientCallablePrivate_JsonArray__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonArray arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonBoolean__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonBoolean__V.java new file mode 100644 index 0000000..25a9b50 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonBoolean__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonBoolean; + +public class LegacyClientCallablePrivate_JsonBoolean__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonBoolean arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNull__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNull__V.java new file mode 100644 index 0000000..aa9fbfe --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNull__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonNull; + +public class LegacyClientCallablePrivate_JsonNull__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonNull arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNumber__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNumber__V.java new file mode 100644 index 0000000..72c559e --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonNumber__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonNumber; + +public class LegacyClientCallablePrivate_JsonNumber__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonNumber arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonObject__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonObject__V.java new file mode 100644 index 0000000..88e4e65 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonObject__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonObject; + +public class LegacyClientCallablePrivate_JsonObject__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonObject arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonString__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonString__V.java new file mode 100644 index 0000000..cc59dfc --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonString__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonString; + +public class LegacyClientCallablePrivate_JsonString__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonString arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonValue__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonValue__V.java new file mode 100644 index 0000000..72d8a34 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_JsonValue__V.java @@ -0,0 +1,11 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.JsonValue; + +public class LegacyClientCallablePrivate_JsonValue__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(JsonValue arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_String__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_String__V.java new file mode 100644 index 0000000..91af544 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_String__V.java @@ -0,0 +1,9 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate_String__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(String arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_Z__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_Z__V.java new file mode 100644 index 0000000..cac566c --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate_Z__V.java @@ -0,0 +1,9 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate_Z__V extends BaseClientCallable { + + @LegacyClientCallable + private void test(boolean arg) { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__D.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__D.java new file mode 100644 index 0000000..c176599 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__D.java @@ -0,0 +1,10 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate__D extends BaseClientCallable { + + @LegacyClientCallable + private double test() { + trace(); + return 0.0; + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__I.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__I.java new file mode 100644 index 0000000..d60bf00 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__I.java @@ -0,0 +1,10 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate__I extends BaseClientCallable { + + @LegacyClientCallable + private int test() { + trace(); + return 0; + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Integer.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Integer.java new file mode 100644 index 0000000..05a646f --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Integer.java @@ -0,0 +1,10 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate__Integer extends BaseClientCallable { + + @LegacyClientCallable + private Integer test() { + trace(); + return 0; + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonArray.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonArray.java new file mode 100644 index 0000000..59285c4 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonArray.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonArray; + +public class LegacyClientCallablePrivate__JsonArray extends BaseClientCallable { + + @LegacyClientCallable + private JsonArray test() { + trace(); + return Json.createArray(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonBoolean.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonBoolean.java new file mode 100644 index 0000000..40abc55 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonBoolean.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonBoolean; + +public class LegacyClientCallablePrivate__JsonBoolean extends BaseClientCallable { + + @LegacyClientCallable + private JsonBoolean test() { + trace(); + return Json.create(true); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNull.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNull.java new file mode 100644 index 0000000..f2a1a56 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNull.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonNull; + +public class LegacyClientCallablePrivate__JsonNull extends BaseClientCallable { + + @LegacyClientCallable + private JsonNull test() { + trace(); + return Json.createNull(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNumber.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNumber.java new file mode 100644 index 0000000..a7ee35e --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonNumber.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonNumber; + +public class LegacyClientCallablePrivate__JsonNumber extends BaseClientCallable { + + @LegacyClientCallable + private JsonNumber test() { + trace(); + return Json.create(0); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonObject.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonObject.java new file mode 100644 index 0000000..d797e02 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonObject.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonObject; + +public class LegacyClientCallablePrivate__JsonObject extends BaseClientCallable { + + @LegacyClientCallable + private JsonObject test() { + trace(); + return Json.createObject(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonString.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonString.java new file mode 100644 index 0000000..08545f4 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonString.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonString; + +public class LegacyClientCallablePrivate__JsonString extends BaseClientCallable { + + @LegacyClientCallable + private JsonString test() { + trace(); + return Json.create(""); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonValue.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonValue.java new file mode 100644 index 0000000..f6eb10e --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__JsonValue.java @@ -0,0 +1,13 @@ +package com.flowingcode.vaadin.jsonmigration; + +import elemental.json.Json; +import elemental.json.JsonValue; + +public class LegacyClientCallablePrivate__JsonValue extends BaseClientCallable { + + @LegacyClientCallable + private JsonValue test() { + trace(); + return Json.createObject(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__V.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__V.java new file mode 100644 index 0000000..8e6fb84 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__V.java @@ -0,0 +1,9 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate__V extends BaseClientCallable { + + @LegacyClientCallable + private void test() { + trace(); + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Z.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Z.java new file mode 100644 index 0000000..54a4d1f --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablePrivate__Z.java @@ -0,0 +1,10 @@ +package com.flowingcode.vaadin.jsonmigration; + +public class LegacyClientCallablePrivate__Z extends BaseClientCallable { + + @LegacyClientCallable + private boolean test() { + trace(); + return true; + } +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest.java new file mode 100644 index 0000000..fdb7b8f --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest.java @@ -0,0 +1,282 @@ +package com.flowingcode.vaadin.jsonmigration; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import com.vaadin.flow.component.ClientCallable; +import com.vaadin.flow.component.Component; +import elemental.json.JsonValue; +import java.lang.annotation.Annotation; +import java.lang.reflect.Method; +import org.junit.Test; + +public abstract class LegacyClientCallablesPrivateTest { + + protected abstract Class instrumentClass(Class clazz); + + private static final String MESSAGE = "instrumented method is not annotated with @ClientCallable"; + + /** + * Finds the test method declared in the instrumented class that is annotated + * with @ClientCallable. + * + * @param c the instrumented callable instance + * @return the Method if found, null otherwise + */ + private static Method getAnnotatedTestMethod(BaseClientCallable c, Class annotationType) { + for (Method method : c.getClass().getDeclaredMethods()) { + if ("test".equals(method.getName()) && method.isAnnotationPresent(annotationType)) { + return method; + } + } + return null; + } + + /** + * Invokes the test method on the instrumented instance via reflection. + * + * @param instrumented the instrumented instance + * @param args the arguments to pass to the test method + * @return the result of the method invocation + * @throws Exception if invocation fails + */ + private static Object invokeTestMethod(BaseClientCallable instrumented, Object... args) throws Exception { + Method testMethod = getAnnotatedTestMethod(instrumented, ClientCallable.class); + assertTrue(MESSAGE, testMethod != null); + testMethod.setAccessible(true); + return testMethod.invoke(instrumented, args); + } + + private static Object invokeLegacyMethod(BaseClientCallable instrumented, Object... args) throws Exception { + Method testMethod = getAnnotatedTestMethod(instrumented, LegacyClientCallable.class); + testMethod.setAccessible(true); + return testMethod.invoke(instrumented, args); + } + + protected abstract Object createJsonNull(); + + protected abstract Object createJsonBoolean(); + + protected abstract Object createJsonNumber(); + + protected abstract Object createJsonString(); + + protected abstract Object createJsonArray(); + + protected abstract Object createJsonObject(); + + @Test + public void testExtends__V() throws Exception { + LegacyClientCallablePrivate__V instrumented = + instrumentClass(ExtendsLegacyClientCallablePrivate__V.class).getDeclaredConstructor() + .newInstance(); + invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test__V() throws Exception { + LegacyClientCallablePrivate__V instrumented = instrumentClass(LegacyClientCallablePrivate__V.class).getDeclaredConstructor() + .newInstance(); + invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_Z__V() throws Exception { + LegacyClientCallablePrivate_Z__V instrumented = instrumentClass(LegacyClientCallablePrivate_Z__V.class).getDeclaredConstructor() + .newInstance(); + invokeTestMethod(instrumented, true); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_I__V() throws Exception { + LegacyClientCallablePrivate_I__V instrumented = instrumentClass(LegacyClientCallablePrivate_I__V.class).getDeclaredConstructor() + .newInstance(); + invokeTestMethod(instrumented, 42); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_D__V() throws Exception { + LegacyClientCallablePrivate_D__V instrumented = instrumentClass(LegacyClientCallablePrivate_D__V.class).getDeclaredConstructor() + .newInstance(); + invokeTestMethod(instrumented, 3.14); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_String__V() throws Exception { + LegacyClientCallablePrivate_String__V instrumented = instrumentClass(LegacyClientCallablePrivate_String__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, "test"); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test__Z() throws Exception { + LegacyClientCallablePrivate__Z instrumented = instrumentClass(LegacyClientCallablePrivate__Z.class).getDeclaredConstructor() + .newInstance(); + LegacyClientCallablePrivate__Z nonInstrumented = new LegacyClientCallablePrivate__Z(); + boolean result = (boolean) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(invokeLegacyMethod(nonInstrumented), result); + } + + @Test + public void test__I() throws Exception { + LegacyClientCallablePrivate__I instrumented = instrumentClass(LegacyClientCallablePrivate__I.class).getDeclaredConstructor() + .newInstance(); + LegacyClientCallablePrivate__I nonInstrumented = new LegacyClientCallablePrivate__I(); + int result = (int) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(invokeLegacyMethod(nonInstrumented), result); + } + + @Test + public void test__D() throws Exception { + LegacyClientCallablePrivate__D instrumented = instrumentClass(LegacyClientCallablePrivate__D.class).getDeclaredConstructor() + .newInstance(); + LegacyClientCallablePrivate__D nonInstrumented = new LegacyClientCallablePrivate__D(); + double result = (double) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals((double) invokeLegacyMethod(nonInstrumented), result, 0.0); + } + + @Test + public void test__Integer() throws Exception { + LegacyClientCallablePrivate__Integer instrumented = instrumentClass(LegacyClientCallablePrivate__Integer.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__Integer nonInstrumented = new LegacyClientCallablePrivate__Integer(); + Integer result = (Integer) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(invokeLegacyMethod(nonInstrumented), result); + } + + @Test + public void test__JsonValue() throws Exception { + LegacyClientCallablePrivate__JsonValue instrumented = instrumentClass(LegacyClientCallablePrivate__JsonValue.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonValue nonInstrumented = new LegacyClientCallablePrivate__JsonValue(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test__JsonBoolean() throws Exception { + LegacyClientCallablePrivate__JsonBoolean instrumented = instrumentClass(LegacyClientCallablePrivate__JsonBoolean.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonBoolean nonInstrumented = new LegacyClientCallablePrivate__JsonBoolean(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test__JsonNumber() throws Exception { + LegacyClientCallablePrivate__JsonNumber instrumented = instrumentClass(LegacyClientCallablePrivate__JsonNumber.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonNumber nonInstrumented = new LegacyClientCallablePrivate__JsonNumber(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test__JsonString() throws Exception { + LegacyClientCallablePrivate__JsonString instrumented = instrumentClass(LegacyClientCallablePrivate__JsonString.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonString nonInstrumented = new LegacyClientCallablePrivate__JsonString(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test__JsonNull() throws Exception { + LegacyClientCallablePrivate__JsonNull instrumented = instrumentClass(LegacyClientCallablePrivate__JsonNull.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonNull nonInstrumented = new LegacyClientCallablePrivate__JsonNull(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test__JsonArray() throws Exception { + LegacyClientCallablePrivate__JsonArray instrumented = instrumentClass(LegacyClientCallablePrivate__JsonArray.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonArray nonInstrumented = new LegacyClientCallablePrivate__JsonArray(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test__JsonObject() throws Exception { + LegacyClientCallablePrivate__JsonObject instrumented = instrumentClass(LegacyClientCallablePrivate__JsonObject.class) + .getDeclaredConstructor().newInstance(); + LegacyClientCallablePrivate__JsonObject nonInstrumented = new LegacyClientCallablePrivate__JsonObject(); + JsonValue result = (JsonValue) invokeTestMethod(instrumented); + assertTrue(instrumented.hasBeenTraced()); + assertEquals(((JsonValue) invokeLegacyMethod(nonInstrumented)).toJson(), result.toJson()); + } + + @Test + public void test_JsonValue__V() throws Exception { + LegacyClientCallablePrivate_JsonValue__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonValue__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonNull()); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_JsonBoolean__V() throws Exception { + LegacyClientCallablePrivate_JsonBoolean__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonBoolean__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonBoolean()); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_JsonNumber__V() throws Exception { + LegacyClientCallablePrivate_JsonNumber__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonNumber__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonNumber()); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_JsonString__V() throws Exception { + LegacyClientCallablePrivate_JsonString__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonString__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonString()); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_JsonNull__V() throws Exception { + LegacyClientCallablePrivate_JsonNull__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonNull__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonNull()); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_JsonArray__V() throws Exception { + LegacyClientCallablePrivate_JsonArray__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonArray__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonArray()); + assertTrue(instrumented.hasBeenTraced()); + } + + @Test + public void test_JsonObject__V() throws Exception { + LegacyClientCallablePrivate_JsonObject__V instrumented = instrumentClass(LegacyClientCallablePrivate_JsonObject__V.class) + .getDeclaredConstructor().newInstance(); + invokeTestMethod(instrumented, createJsonObject()); + assertTrue(instrumented.hasBeenTraced()); + } + +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest24.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest24.java new file mode 100644 index 0000000..a73df01 --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest24.java @@ -0,0 +1,44 @@ +package com.flowingcode.vaadin.jsonmigration; + +import com.vaadin.flow.component.Component; +import elemental.json.Json; + +public class LegacyClientCallablesPrivateTest24 extends LegacyClientCallablesPrivateTest { + + @Override + protected Class instrumentClass(Class clazz) { + return new LegacyJsonMigrationHelper().instrumentClass(clazz); + } + + @Override + protected Object createJsonNull() { + return Json.createNull(); + } + + @Override + protected Object createJsonBoolean() { + return Json.create(true); + } + + @Override + protected Object createJsonNumber() { + return Json.create(42); + } + + @Override + protected Object createJsonString() { + return Json.create("test"); + } + + @Override + protected Object createJsonArray() { + return Json.createArray(); + } + + @Override + protected Object createJsonObject() { + return Json.createObject(); + } + + +} diff --git a/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest25.java b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest25.java new file mode 100644 index 0000000..a6245ff --- /dev/null +++ b/src/test/java/com/flowingcode/vaadin/jsonmigration/LegacyClientCallablesPrivateTest25.java @@ -0,0 +1,50 @@ +package com.flowingcode.vaadin.jsonmigration; + +import com.vaadin.flow.component.Component; +import tools.jackson.databind.node.ArrayNode; +import tools.jackson.databind.node.BooleanNode; +import tools.jackson.databind.node.DoubleNode; +import tools.jackson.databind.node.JsonNodeFactory; +import tools.jackson.databind.node.NullNode; +import tools.jackson.databind.node.ObjectNode; +import tools.jackson.databind.node.StringNode; + +// this test doesn't work as-in because it requires Vaadin 25 in the classpath +public class LegacyClientCallablesPrivateTest25 extends LegacyClientCallablesPrivateTest { + + @Override + protected Class instrumentClass(Class clazz) { + return new JsonMigrationHelper25().instrumentClass(clazz); + } + + @Override + protected Object createJsonNull() { + return NullNode.getInstance(); + } + + @Override + protected Object createJsonBoolean() { + return BooleanNode.TRUE; + } + + @Override + protected Object createJsonNumber() { + return DoubleNode.valueOf(42); + } + + @Override + protected Object createJsonString() { + return StringNode.valueOf("test"); + } + + @Override + protected Object createJsonArray() { + return new ArrayNode(JsonNodeFactory.instance); + } + + @Override + protected Object createJsonObject() { + return new ObjectNode(JsonNodeFactory.instance); + } + +} From b8ebbcf61234877e16a2ba9d88b4d59f86861425 Mon Sep 17 00:00:00 2001 From: Javier Godoy <11554739+javier-godoy@users.noreply.github.com> Date: Mon, 1 Dec 2025 20:46:40 -0300 Subject: [PATCH 2/2] refactor: remove redundant condition --- .../jsonmigration/ClassInstrumentationUtil.java | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java b/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java index f6dad70..9de045f 100644 --- a/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java +++ b/src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java @@ -199,19 +199,10 @@ private List getInstrumentableMethods(Class parent) { if (hasLegacyVaadin()) { return isLegacyCallable; + } else { + return (isCallable && hasJsonValueReturn) || isLegacyCallable; } - if (isCallable || isLegacyCallable) { - - if (isCallable && hasJsonValueReturn) { - return true; - } else if (isLegacyCallable) { - return true; - } - } - - return false; - }).collect(Collectors.toList()); }