Added LRUCache and ClassUtilities.

jdereg · Nov 12, 2023 · 8ced442 · 8ced442
1 parent 8921bc1
commit 8ced442
Show file tree

Hide file tree

Showing 4 changed files with 259 additions and 15 deletions.
diff --git a/pom.xml b/pom.xml
@@ -29,9 +29,9 @@
 <!--        <maven.compiler.release>11</maven.compiler.release>-->
 
         <!-- testing only -->
-        <version.junit>5.10.0</version.junit>
+        <version.junit>5.10.1</version.junit>
         <version.assertj>3.24.2</version.assertj>
-        <version.json.io>4.14.1</version.json.io>
+        <version.json.io>4.16.0</version.json.io>
         <version.mockito.inline>4.11.0</version.mockito.inline>
         <version.agrona>1.19.2</version.agrona>
 
@@ -41,8 +41,8 @@
         <!-- Build maven-***-plugins -->
         <version.plugin.gpg>3.1.0</version.plugin.gpg>
         <version.plugin.compiler>3.11.0</version.plugin.compiler>
-        <version.plugin.javadoc>3.6.0</version.plugin.javadoc>
-        <version.plugin.surefire>3.2.1</version.plugin.surefire>
+        <version.plugin.javadoc>3.6.2</version.plugin.javadoc>
+        <version.plugin.surefire>3.2.2</version.plugin.surefire>
         <version.plugin.source>3.3.0</version.plugin.source>
         <version.plugin.felix.scr>1.26.4</version.plugin.felix.scr>
         <version.plugin.felix.bundle>5.1.9</version.plugin.felix.bundle>

diff --git a/src/main/java/com/cedarsoftware/util/ClassUtilities.java b/src/main/java/com/cedarsoftware/util/ClassUtilities.java
@@ -131,15 +131,15 @@ public static boolean isPrimitive(Class<?> c)
      * Compare two primitives.
      * @return 0 if they are the same, -1 if not.  Primitive wrapper classes are consider the same as primitive classes.
      */
-    public static int comparePrimitiveToWrapper(Class<?> source, Class<?> destination)
+    private static int comparePrimitiveToWrapper(Class<?> source, Class<?> destination)
     {
         try
         {
             return source.getField("TYPE").get(null).equals(destination) ? 0 : -1;
         }
         catch (Exception e)
         {
-            throw new RuntimeException("Error while attempting comparison of primitive types: " + source.getName() + " vs " + destination.getName(), e);
+            return -1;
         }
     }
 }
diff --git a/src/test/java/com/cedarsoftware/util/ClassUtilitiesTest.java b/src/test/java/com/cedarsoftware/util/ClassUtilitiesTest.java
@@ -0,0 +1,155 @@
+package com.cedarsoftware.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ClassUtilitiesTest {
+    // Example classes and interfaces for testing
+    interface TestInterface {}
+    interface SubInterface extends TestInterface {}
+    static class TestClass {}
+    static class SubClass extends TestClass implements TestInterface {}
+    static class AnotherClass {}
+
+    @Test
+    void testComputeInheritanceDistanceWithNulls() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(null, null));
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(String.class, null));
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(null, Object.class));
+    }
+
+    @Test
+    void testComputeInheritanceDistanceWithSameClass() {
+        assertEquals(0, ClassUtilities.computeInheritanceDistance(String.class, String.class));
+        assertEquals(0, ClassUtilities.computeInheritanceDistance(Object.class, Object.class));
+    }
+
+    @Test
+    void testComputeInheritanceDistanceWithSuperclass() {
+        assertEquals(1, ClassUtilities.computeInheritanceDistance(String.class, Object.class));
+        assertEquals(1, ClassUtilities.computeInheritanceDistance(Integer.class, Number.class));
+    }
+
+    @Test
+    void testComputeInheritanceDistanceWithInterface() {
+        assertEquals(1, ClassUtilities.computeInheritanceDistance(ArrayList.class, List.class));
+        assertEquals(2, ClassUtilities.computeInheritanceDistance(HashSet.class, Collection.class));
+    }
+
+    @Test
+    void testComputeInheritanceDistanceUnrelatedClasses() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(String.class, List.class));
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(HashMap.class, List.class));
+    }
+
+    @Test
+    void testIsPrimitive() {
+        assertTrue(ClassUtilities.isPrimitive(int.class));
+        assertTrue(ClassUtilities.isPrimitive(Integer.class));
+        assertFalse(ClassUtilities.isPrimitive(String.class));
+    }
+
+    @Test
+    public void testClassToClassDirectInheritance() {
+        assertEquals(1, ClassUtilities.computeInheritanceDistance(SubClass.class, TestClass.class),
+                "Direct class to class inheritance should have a distance of 1.");
+    }
+
+    @Test
+    public void testClassToClassNoInheritance() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(TestClass.class, AnotherClass.class),
+                "No inheritance between classes should return -1.");
+    }
+
+    @Test
+    public void testClassToInterfaceDirectImplementation() {
+        assertEquals(1, ClassUtilities.computeInheritanceDistance(SubClass.class, TestInterface.class),
+                "Direct class to interface implementation should have a distance of 1.");
+    }
+
+    @Test
+    public void testClassToInterfaceNoImplementation() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(TestClass.class, TestInterface.class),
+                "No implementation of the interface by the class should return -1.");
+    }
+
+    @Test
+    public void testInterfaceToClass() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(TestInterface.class, TestClass.class),
+                "Interface to class should always return -1 as interfaces cannot inherit from classes.");
+    }
+
+    @Test
+    public void testInterfaceToInterfaceDirectInheritance() {
+        assertEquals(1, ClassUtilities.computeInheritanceDistance(SubInterface.class, TestInterface.class),
+                "Direct interface to interface inheritance should have a distance of 1.");
+    }
+
+    @Test
+    public void testInterfaceToInterfaceNoInheritance() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(TestInterface.class, SubInterface.class),
+                "No inheritance between interfaces should return -1.");
+    }
+
+    @Test
+    public void testSameClass() {
+        assertEquals(0, ClassUtilities.computeInheritanceDistance(TestClass.class, TestClass.class),
+                "Distance from a class to itself should be 0.");
+    }
+
+    @Test
+    public void testSameInterface() {
+        assertEquals(0, ClassUtilities.computeInheritanceDistance(TestInterface.class, TestInterface.class),
+                "Distance from an interface to itself should be 0.");
+    }
+
+    @Test
+    public void testWithNullSource() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(null, TestClass.class),
+                "Should return -1 when source is null.");
+    }
+
+    @Test
+    public void testWithNullDestination() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(TestClass.class, null),
+                "Should return -1 when destination is null.");
+    }
+
+    @Test
+    public void testWithBothNull() {
+        assertEquals(-1, ClassUtilities.computeInheritanceDistance(null, null),
+                "Should return -1 when both source and destination are null.");
+    }
+
+    @Test
+    public void testPrimitives() {
+        assert 0 == ClassUtilities.computeInheritanceDistance(byte.class, Byte.TYPE);
+        assert 0 == ClassUtilities.computeInheritanceDistance(Byte.TYPE, byte.class);
+        assert 0 == ClassUtilities.computeInheritanceDistance(Byte.TYPE, Byte.class);
+        assert 0 == ClassUtilities.computeInheritanceDistance(Byte.class, Byte.TYPE);
+        assert 0 == ClassUtilities.computeInheritanceDistance(Byte.class, byte.class);
+        assert 0 == ClassUtilities.computeInheritanceDistance(int.class, Integer.class);
+        assert 0 == ClassUtilities.computeInheritanceDistance(Integer.class, int.class);
+
+        assert -1 == ClassUtilities.computeInheritanceDistance(Byte.class, int.class);
+        assert -1 == ClassUtilities.computeInheritanceDistance(int.class, Byte.class);
+        assert -1 == ClassUtilities.computeInheritanceDistance(int.class, String.class);
+        assert -1 == ClassUtilities.computeInheritanceDistance(int.class, String.class);
+        assert -1 == ClassUtilities.computeInheritanceDistance(Short.TYPE, Integer.TYPE);
+        assert -1 == ClassUtilities.computeInheritanceDistance(String.class, Integer.TYPE);
+
+        assert -1 == ClassUtilities.computeInheritanceDistance(Date.class, java.sql.Date.class);
+        assert 1 == ClassUtilities.computeInheritanceDistance(java.sql.Date.class, Date.class);
+    }
+
+}
diff --git a/src/test/java/com/cedarsoftware/util/TestReflectionUtils.java b/src/test/java/com/cedarsoftware/util/TestReflectionUtils.java
@@ -3,21 +3,30 @@
 import org.junit.jupiter.api.Test;
 
 import java.io.InputStream;
-import java.lang.annotation.*;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.util.*;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 /**
  * @author John DeRegnaucourt ([email protected])
@@ -234,6 +243,8 @@ public void testGetClassName() throws Exception
     {
         assertEquals("null", ReflectionUtils.getClassName((Object)null));
         assertEquals("java.lang.String", ReflectionUtils.getClassName("item"));
+        assertEquals("java.lang.String", ReflectionUtils.getClassName(""));
+        assertEquals("null", ReflectionUtils.getClassName(null));
     }
 
     @Test
@@ -663,4 +674,82 @@ private static URL[] getClasspathURLs()
             }
         }
     }
+
+
+    @Retention(RetentionPolicy.RUNTIME)
+    private @interface TestAnnotation {}
+
+    @TestAnnotation
+    private static class AnnotatedTestClass {
+        @Override
+        public String toString()
+        {
+            return super.toString();
+        }
+    }
+
+    private static class TestClass {
+        private int field1;
+        public int field2;
+    }
+
+    @Test
+    void testGetClassAnnotation() {
+        assertNotNull(ReflectionUtils.getClassAnnotation(AnnotatedTestClass.class, TestAnnotation.class));
+        assertNull(ReflectionUtils.getClassAnnotation(TestClass.class, TestAnnotation.class));
+    }
+
+    @Test
+    void testGetMethodAnnotation() throws NoSuchMethodException {
+        Method method = AnnotatedTestClass.class.getDeclaredMethod("toString");
+        assertNull(ReflectionUtils.getMethodAnnotation(method, TestAnnotation.class));
+    }
+
+    @Test
+    void testGetMethod() throws NoSuchMethodException {
+        Method method = ReflectionUtils.getMethod(TestClass.class, "toString");
+        assertNotNull(method);
+        assertEquals("toString", method.getName());
+
+        assertNull(ReflectionUtils.getMethod(TestClass.class, "nonExistentMethod"));
+    }
+
+    @Test
+    void testGetDeepDeclaredFields() {
+        Collection<Field> fields = ReflectionUtils.getDeepDeclaredFields(TestClass.class);
+        assertEquals(2, fields.size()); // field1 and field2
+    }
+
+    @Test
+    void testGetDeepDeclaredFieldMap() {
+        Map<String, Field> fieldMap = ReflectionUtils.getDeepDeclaredFieldMap(TestClass.class);
+        assertEquals(2, fieldMap.size());
+        assertTrue(fieldMap.containsKey("field1"));
+        assertTrue(fieldMap.containsKey("field2"));
+    }
+
+    @Test
+    void testCall() throws NoSuchMethodException {
+        TestClass testInstance = new TestClass();
+        Method method = TestClass.class.getMethod("toString");
+        String result = (String) ReflectionUtils.call(testInstance, method);
+        assertEquals(testInstance.toString(), result);
+    }
+
+    @Test
+    void testCallWithArgs() throws NoSuchMethodException {
+        TestClass testInstance = new TestClass();
+        String methodName = "equals";
+        Object[] args = new Object[]{testInstance};
+        Boolean result = (Boolean) ReflectionUtils.call(testInstance, methodName, args);
+        assertTrue(result);
+    }
+
+    @Test
+    void testGetNonOverloadedMethod() {
+        Method method = ReflectionUtils.getNonOverloadedMethod(TestClass.class, "toString");
+        assertNotNull(method);
+        assertEquals("toString", method.getName());
+    }
 }
+