add ReflectionHacksTest

fprochazka · fprochazka · commit b98f220a6563 · 2025-07-27T18:26:13.000+02:00
diff --git a/modules/typed-ids-hibernate-61/src/main/java/org/framefork/typedIds/bigint/hibernate/ObjectBigIntIdJavaType.java b/modules/typed-ids-hibernate-61/src/main/java/org/framefork/typedIds/bigint/hibernate/ObjectBigIntIdJavaType.java
@@ -59,7 +59,7 @@ public void setParameterValues(final Properties parameters)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectBigIntId.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, long.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, long.class);
     }
 
     @Override
diff --git a/modules/typed-ids-hibernate-61/src/main/java/org/framefork/typedIds/uuid/hibernate/ObjectUuidJavaType.java b/modules/typed-ids-hibernate-61/src/main/java/org/framefork/typedIds/uuid/hibernate/ObjectUuidJavaType.java
@@ -65,7 +65,7 @@ public void setParameterValues(final Properties parameters)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);
     }
 
     @Override
diff --git a/modules/typed-ids-hibernate-62/src/main/java/org/framefork/typedIds/bigint/hibernate/ObjectBigIntIdJavaType.java b/modules/typed-ids-hibernate-62/src/main/java/org/framefork/typedIds/bigint/hibernate/ObjectBigIntIdJavaType.java
@@ -59,7 +59,7 @@ public void setParameterValues(final Properties parameters)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectBigIntId.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, long.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, long.class);
     }
 
     @Override
diff --git a/modules/typed-ids-hibernate-62/src/main/java/org/framefork/typedIds/uuid/hibernate/ObjectUuidJavaType.java b/modules/typed-ids-hibernate-62/src/main/java/org/framefork/typedIds/uuid/hibernate/ObjectUuidJavaType.java
@@ -65,7 +65,7 @@ public void setParameterValues(final Properties parameters)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);
     }
 
     @Override
diff --git a/modules/typed-ids-hibernate-63/src/main/java/org/framefork/typedIds/bigint/hibernate/ObjectBigIntIdJavaType.java b/modules/typed-ids-hibernate-63/src/main/java/org/framefork/typedIds/bigint/hibernate/ObjectBigIntIdJavaType.java
@@ -59,7 +59,7 @@ public void setParameterValues(final Properties parameters)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectBigIntId.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, long.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, long.class);
     }
 
     @Override
diff --git a/modules/typed-ids-hibernate-63/src/main/java/org/framefork/typedIds/uuid/hibernate/ObjectUuidJavaType.java b/modules/typed-ids-hibernate-63/src/main/java/org/framefork/typedIds/uuid/hibernate/ObjectUuidJavaType.java
@@ -65,7 +65,7 @@ public void setParameterValues(final Properties parameters)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);
     }
 
     @Override
diff --git a/modules/typed-ids/src/main/java/org/framefork/typedIds/bigint/json/gson/ObjectBigIntIdTypeAdapter.java b/modules/typed-ids/src/main/java/org/framefork/typedIds/bigint/json/gson/ObjectBigIntIdTypeAdapter.java
@@ -21,7 +21,7 @@ public ObjectBigIntIdTypeAdapter(final Class<T> identifierClass)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectBigIntId.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, long.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, long.class);
     }
 
     @Override
diff --git a/modules/typed-ids/src/main/java/org/framefork/typedIds/common/ReflectionHacks.java b/modules/typed-ids/src/main/java/org/framefork/typedIds/common/ReflectionHacks.java
@@ -71,7 +71,7 @@ public static <ExpectedType> Class<ExpectedType> getFieldTypeChecked(
         return (Class<ExpectedType>) declaredFieldType;
     }
 
-    public static MethodHandle getMainConstructor(final Class<?> type, final Class<?>... parameterTypes)
+    public static MethodHandle getConstructor(final Class<?> type, final Class<?>... parameterTypes)
     {
         try {
             Constructor<?> constructor = type.getDeclaredConstructor(parameterTypes);
diff --git a/modules/typed-ids/src/main/java/org/framefork/typedIds/uuid/json/gson/ObjectUuidTypeAdapter.java b/modules/typed-ids/src/main/java/org/framefork/typedIds/uuid/json/gson/ObjectUuidTypeAdapter.java
@@ -22,7 +22,7 @@ public ObjectUuidTypeAdapter(final Class<T> identifierClass)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);
     }
 
     @Override
diff --git a/modules/typed-ids/src/main/java/org/framefork/typedIds/uuid/json/jackson/ObjectUuidDeserializer.java b/modules/typed-ids/src/main/java/org/framefork/typedIds/uuid/json/jackson/ObjectUuidDeserializer.java
@@ -22,7 +22,7 @@ public ObjectUuidDeserializer(final Class<?> identifierClass)
             throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));
         }
 
-        this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);
+        this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);
     }
 
     @Override
diff --git a/modules/typed-ids/src/main/kotlin/org/framefork/typedIds/bigint/json/kotlinxSerialization/ObjectBigIntIdKotlinxSerializationModule.kt b/modules/typed-ids/src/main/kotlin/org/framefork/typedIds/bigint/json/kotlinxSerialization/ObjectBigIntIdKotlinxSerializationModule.kt
@@ -33,7 +33,7 @@ public object ObjectBigIntIdKotlinxSerializationModule {
         @Suppress("UNCHECKED_CAST")
         fun <T : Any> typedIdConstructor(javaClass: Class<T>): (Long) -> T =
             constructorByType.computeIfAbsent(javaClass.name) {
-                val mainConstructor = ReflectionHacks.getMainConstructor(javaClass, *arrayOf(Long::class.java));
+                val mainConstructor = ReflectionHacks.getConstructor(javaClass, *arrayOf(Long::class.java));
                 return@computeIfAbsent { raw -> ObjectBigIntIdTypeUtils.wrapBigIntToIdentifier(raw, mainConstructor) };
             } as (Long) -> T
 
diff --git a/modules/typed-ids/src/main/kotlin/org/framefork/typedIds/uuid/json/kotlinxSerialization/ObjectUuidKotlinxSerializationModule.kt b/modules/typed-ids/src/main/kotlin/org/framefork/typedIds/uuid/json/kotlinxSerialization/ObjectUuidKotlinxSerializationModule.kt
@@ -34,7 +34,7 @@ public object ObjectUuidKotlinxSerializationModule {
         @Suppress("UNCHECKED_CAST")
         fun <T : Any> typedIdConstructor(javaClass: Class<T>): (UUID) -> T =
             constructorByType.computeIfAbsent(javaClass.name) {
-                val mainConstructor = ReflectionHacks.getMainConstructor(javaClass, *arrayOf(UUID::class.java));
+                val mainConstructor = ReflectionHacks.getConstructor(javaClass, *arrayOf(UUID::class.java));
                 return@computeIfAbsent { raw -> ObjectUuidTypeUtils.wrapUuidToIdentifier(raw, mainConstructor) };
             } as (UUID) -> T
 
diff --git a/modules/typed-ids/src/test/java/org/framefork/typedIds/common/ReflectionHacksTest.java b/modules/typed-ids/src/test/java/org/framefork/typedIds/common/ReflectionHacksTest.java
@@ -0,0 +1,268 @@
+package org.framefork.typedIds.common;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.Serializable;
+import java.lang.invoke.MethodHandle;
+
+final class ReflectionHacksTest
+{
+
+    @Nested
+    final class ClassForName
+    {
+
+        @Test
+        public void shouldReturnClassWhenExists()
+        {
+            Class<String> result = ReflectionHacks.classForName("java.lang.String");
+
+            Assertions.assertNotNull(result);
+            Assertions.assertEquals(String.class, result);
+        }
+
+        @Test
+        public void shouldReturnNullWhenClassNotFound()
+        {
+            Class<Object> result = ReflectionHacks.classForName("com.nonexistent.Class");
+
+            Assertions.assertNull(result);
+        }
+
+    }
+
+    @Nested
+    final class ClassExists
+    {
+
+        @Test
+        public void shouldReturnTrueWhenClassExists()
+        {
+            boolean result = ReflectionHacks.classExists("java.lang.String");
+
+            Assertions.assertTrue(result);
+        }
+
+        @Test
+        public void shouldReturnFalseWhenClassDoesNotExist()
+        {
+            boolean result = ReflectionHacks.classExists("com.nonexistent.Class");
+
+            Assertions.assertFalse(result);
+        }
+
+    }
+
+    @Nested
+    final class GetFieldType
+    {
+
+        @Test
+        public void shouldReturnFieldTypeWhenFieldExists()
+        {
+            Class<?> result = ReflectionHacks.getFieldType(
+                "org.framefork.typedIds.common.ReflectionHacksTest$TestClass",
+                "stringField"
+            );
+
+            Assertions.assertEquals(String.class, result);
+        }
+
+        @Test
+        public void shouldThrowWhenClassNotFound()
+        {
+            IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> ReflectionHacks.getFieldType("com.nonexistent.Class", "field")
+            );
+
+            Assertions.assertInstanceOf(ClassNotFoundException.class, exception.getCause());
+        }
+
+        @Test
+        public void shouldThrowWhenFieldNotFound()
+        {
+            IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> ReflectionHacks.getFieldType(
+                    "org.framefork.typedIds.common.ReflectionHacksTest$TestClass",
+                    "nonexistentField"
+                )
+            );
+
+            Assertions.assertInstanceOf(NoSuchFieldException.class, exception.getCause());
+        }
+
+    }
+
+    @Nested
+    final class GetFieldTypeChecked
+    {
+
+        @Test
+        public void shouldReturnFieldTypeWhenAssignable()
+        {
+            Class<String> result = ReflectionHacks.getFieldTypeChecked(
+                "org.framefork.typedIds.common.ReflectionHacksTest$TestClass",
+                "stringField",
+                String.class
+            );
+
+            Assertions.assertEquals(String.class, result);
+        }
+
+        @Test
+        public void shouldReturnFieldTypeWhenSubtype()
+        {
+            Class<Serializable> result = ReflectionHacks.getFieldTypeChecked(
+                "org.framefork.typedIds.common.ReflectionHacksTest$TestClass",
+                "stringField",
+                Serializable.class
+            );
+
+            Assertions.assertEquals(String.class, result);
+        }
+
+        @Test
+        public void shouldThrowWhenNotAssignable()
+        {
+            IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> ReflectionHacks.getFieldTypeChecked(
+                    "org.framefork.typedIds.common.ReflectionHacksTest$TestClass",
+                    "stringField",
+                    Integer.class
+                )
+            );
+
+            assertThat(exception).hasMessageContaining("is expected to be an instance of");
+        }
+
+    }
+
+    @Nested
+    final class GetConstructor
+    {
+
+        @Test
+        public void shouldReturnConstructorHandle()
+        {
+            MethodHandle constructor = ReflectionHacks.getConstructor(TestClass.class, String.class);
+
+            Assertions.assertNotNull(constructor);
+            Assertions.assertEquals("MethodHandle(String)TestClass", constructor.toString());
+        }
+
+        @Test
+        public void shouldReturnNoArgsConstructorHandle()
+        {
+            MethodHandle constructor = ReflectionHacks.getConstructor(TestClass.class);
+
+            Assertions.assertNotNull(constructor);
+            Assertions.assertEquals("MethodHandle()TestClass", constructor.toString());
+        }
+
+        @Test
+        public void shouldThrowWhenConstructorNotFound()
+        {
+            IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> ReflectionHacks.getConstructor(TestClass.class, Integer.class, Long.class)
+            );
+
+            assertThat(exception)
+                .hasMessageContaining("Cannot resolve constructor")
+                .hasCauseInstanceOf(NoSuchMethodException.class);
+        }
+
+        @Test
+        public void shouldInvokeConstructorSuccessfully() throws Throwable
+        {
+            MethodHandle constructor = ReflectionHacks.getConstructor(TestClass.class, String.class);
+
+            var instance = (TestClass) constructor.invoke("test-value");
+
+            Assertions.assertNotNull(instance);
+            Assertions.assertEquals("test-value", instance.stringField);
+        }
+
+    }
+
+    @Nested
+    final class GetAllInterfaces
+    {
+
+        @Test
+        public void shouldReturnAllInterfaces()
+        {
+            var instance = new TestClass();
+
+            Class<?>[] interfaces = ReflectionHacks.getAllInterfaces(instance);
+
+            assertThat(interfaces)
+                .isNotEmpty()
+                .contains(Serializable.class);
+        }
+
+        @Test
+        public void shouldReturnEmptyForObject()
+        {
+            var instance = new Object();
+
+            Class<?>[] interfaces = ReflectionHacks.getAllInterfaces(instance);
+
+            Assertions.assertEquals(0, interfaces.length);
+        }
+
+        @Test
+        public void shouldReturnInterfacesFromSuperclass()
+        {
+            var instance = new TestSubClass();
+
+            Class<?>[] interfaces = ReflectionHacks.getAllInterfaces(instance);
+
+            assertThat(interfaces)
+                .isNotEmpty()
+                .contains(Serializable.class, Comparable.class);
+        }
+
+    }
+
+    public static class TestClass implements Serializable
+    {
+
+        public String stringField;
+
+        public TestClass()
+        {
+            this.stringField = "default";
+        }
+
+        public TestClass(String stringField)
+        {
+            this.stringField = stringField;
+        }
+
+    }
+
+    public static class TestSubClass extends TestClass implements Comparable<TestSubClass>
+    {
+
+        public TestSubClass()
+        {
+            super();
+        }
+
+        @Override
+        public int compareTo(TestSubClass o)
+        {
+            return 0;
+        }
+
+    }
+
+}

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public void setParameterValues(final Properties parameters)`
`59`	`59`	`throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectBigIntId.class));`
`60`	`60`	`}`
`61`	`61`
`62`		`- this.constructor = ReflectionHacks.getMainConstructor(identifierClass, long.class);`
	`62`	`+ this.constructor = ReflectionHacks.getConstructor(identifierClass, long.class);`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public void setParameterValues(final Properties parameters)`
`65`	`65`	`throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));`
`66`	`66`	`}`
`67`	`67`
`68`		`- this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);`
	`68`	`+ this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public ObjectBigIntIdTypeAdapter(final Class<T> identifierClass)`
`21`	`21`	`throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectBigIntId.class));`
`22`	`22`	`}`
`23`	`23`
`24`		`- this.constructor = ReflectionHacks.getMainConstructor(identifierClass, long.class);`
	`24`	`+ this.constructor = ReflectionHacks.getConstructor(identifierClass, long.class);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public static <ExpectedType> Class<ExpectedType> getFieldTypeChecked(`
`71`	`71`	`return (Class<ExpectedType>) declaredFieldType;`
`72`	`72`	`}`
`73`	`73`
`74`		`- public static MethodHandle getMainConstructor(final Class<?> type, final Class<?>... parameterTypes)`
	`74`	`+ public static MethodHandle getConstructor(final Class<?> type, final Class<?>... parameterTypes)`
`75`	`75`	`{`
`76`	`76`	`try {`
`77`	`77`	`Constructor<?> constructor = type.getDeclaredConstructor(parameterTypes);`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public ObjectUuidTypeAdapter(final Class<T> identifierClass)`
`22`	`22`	`throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));`
`23`	`23`	`}`
`24`	`24`
`25`		`- this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);`
	`25`	`+ this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public ObjectUuidDeserializer(final Class<?> identifierClass)`
`22`	`22`	`throw new IllegalArgumentException("Type %s is not a subtype of %s".formatted(identifierClass, ObjectUuid.class));`
`23`	`23`	`}`
`24`	`24`
`25`		`- this.constructor = ReflectionHacks.getMainConstructor(identifierClass, UUID.class);`
	`25`	`+ this.constructor = ReflectionHacks.getConstructor(identifierClass, UUID.class);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Override`