Remove unused Main class and add comprehensive test coverage

- Delete obsolete Main.java

- Add unit tests for utility classes, resource loading, logging, and property builder

Author: y1j2x34

propify/src/main/java/com/vgerbot/propify/Main.java

@@ -0,0 +1,41 @@
+package com.vgerbot.propify.common;
+
+import org.junit.Test;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Test for the ReflectionUtils constructor to ensure it cannot be instantiated.
+ */
+public class ReflectionUtils_ConstructorTest {
+
+    /**
+     * Test that the ReflectionUtils constructor throws a PropifyException when attempting to instantiate it.
+     * This verifies that the utility class is properly designed to prevent instantiation.
+     */
+    @Test
+    public void testConstructor_ThrowsPropifyException() {
+        try {
+            // Get the private constructor
+            Constructor<ReflectionUtils> constructor = ReflectionUtils.class.getDeclaredConstructor();
+            // Make it accessible
+            constructor.setAccessible(true);
+            // Try to create a new instance
+            constructor.newInstance();
+            // If we get here, the test should fail
+            fail("Expected PropifyException was not thrown");
+        } catch (InvocationTargetException e) {
+            // The constructor should throw a PropifyException
+            Throwable cause = e.getCause();
+            assertTrue("Expected PropifyException but got: " + cause.getClass().getName(), 
+                      cause instanceof PropifyException);
+            assertEquals("Cannot instantiate ReflectionUtils class", cause.getMessage());
+        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+}

propify/src/test/java/com/vgerbot/propify/common/ReflectionUtils_ConstructorTest.java

@@ -0,0 +1,226 @@
+package com.vgerbot.propify.common;
+
+import org.junit.Test;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import static org.junit.Assert.*;
+
+/**
+ * Tests for the utility methods in ReflectionUtils class.
+ */
+public class ReflectionUtils_MethodsTest {
+
+    // Test class with various members for testing reflection
+    private static class TestClass {
+        private String privateField;
+        public String publicField;
+        
+        private TestClass() {}
+        
+        public TestClass(String value) {
+            this.privateField = value;
+        }
+        
+        private void privateMethod() {}
+        
+        public void publicMethod() {}
+        
+        private String privateMethodWithParams(String param1, int param2) {
+            return param1 + param2;
+        }
+    }
+
+    /**
+     * Test for makeAccessible method with an already accessible object.
+     */
+    @Test
+    public void testMakeAccessible_AlreadyAccessible() {
+        // Create an accessible object
+        AccessibleObject object = TestClass.class.getFields()[0]; // publicField
+        object.setAccessible(true);
+        
+        // Call makeAccessible
+        ReflectionUtils.makeAccessible(object);
+        
+        // Verify it's still accessible
+        assertTrue(object.isAccessible());
+    }
+
+    /**
+     * Test for makeAccessible method with an inaccessible object.
+     */
+    @Test
+    public void testMakeAccessible_Inaccessible() {
+        // Create an inaccessible object
+        AccessibleObject object = null;
+        try {
+            object = TestClass.class.getDeclaredField("privateField");
+            object.setAccessible(false);
+        } catch (NoSuchFieldException e) {
+            fail("Test setup failed: " + e.getMessage());
+        }
+        
+        // Call makeAccessible
+        ReflectionUtils.makeAccessible(object);
+        
+        // Verify it's now accessible
+        assertTrue(object.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredConstructor method with a public constructor.
+     */
+    @Test
+    public void testGetDeclaredConstructor_PublicConstructor() {
+        // Get public constructor
+        Constructor<TestClass> constructor = ReflectionUtils.getDeclaredConstructor(TestClass.class, String.class);
+        
+        // Verify it's the correct constructor
+        assertNotNull(constructor);
+        assertEquals(1, constructor.getParameterCount());
+        assertEquals(String.class, constructor.getParameterTypes()[0]);
+        assertTrue(constructor.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredConstructor method with a private constructor.
+     */
+    @Test
+    public void testGetDeclaredConstructor_PrivateConstructor() {
+        // Get private constructor
+        Constructor<TestClass> constructor = ReflectionUtils.getDeclaredConstructor(TestClass.class);
+        
+        // Verify it's the correct constructor
+        assertNotNull(constructor);
+        assertEquals(0, constructor.getParameterCount());
+        assertTrue(constructor.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredConstructor method when constructor doesn't exist.
+     */
+    @Test
+    public void testGetDeclaredConstructor_NonExistentConstructor() {
+        try {
+            // Try to get a constructor that doesn't exist
+            ReflectionUtils.getDeclaredConstructor(TestClass.class, Integer.class, Boolean.class);
+            fail("Expected PropifyException was not thrown");
+        } catch (PropifyException e) {
+            // Verify the exception message
+            assertTrue(e.getMessage().contains("Failed to get constructor"));
+            assertTrue(e.getCause() instanceof NoSuchMethodException);
+        }
+    }
+
+    /**
+     * Test for getDeclaredField method with a public field.
+     */
+    @Test
+    public void testGetDeclaredField_PublicField() {
+        // Get public field
+        Field field = ReflectionUtils.getDeclaredField(TestClass.class, "publicField");
+        
+        // Verify it's the correct field
+        assertNotNull(field);
+        assertEquals("publicField", field.getName());
+        assertTrue(field.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredField method with a private field.
+     */
+    @Test
+    public void testGetDeclaredField_PrivateField() {
+        // Get private field
+        Field field = ReflectionUtils.getDeclaredField(TestClass.class, "privateField");
+        
+        // Verify it's the correct field
+        assertNotNull(field);
+        assertEquals("privateField", field.getName());
+        assertTrue(field.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredField method when field doesn't exist.
+     */
+    @Test
+    public void testGetDeclaredField_NonExistentField() {
+        try {
+            // Try to get a field that doesn't exist
+            ReflectionUtils.getDeclaredField(TestClass.class, "nonExistentField");
+            fail("Expected PropifyException was not thrown");
+        } catch (PropifyException e) {
+            // Verify the exception message
+            assertTrue(e.getMessage().contains("Failed to get field"));
+            assertTrue(e.getCause() instanceof NoSuchFieldException);
+        }
+    }
+
+    /**
+     * Test for getDeclaredMethod method with a public method.
+     */
+    @Test
+    public void testGetDeclaredMethod_PublicMethod() {
+        // Get public method
+        Method method = ReflectionUtils.getDeclaredMethod(TestClass.class, "publicMethod");
+        
+        // Verify it's the correct method
+        assertNotNull(method);
+        assertEquals("publicMethod", method.getName());
+        assertEquals(0, method.getParameterCount());
+        assertTrue(method.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredMethod method with a private method.
+     */
+    @Test
+    public void testGetDeclaredMethod_PrivateMethod() {
+        // Get private method
+        Method method = ReflectionUtils.getDeclaredMethod(TestClass.class, "privateMethod");
+        
+        // Verify it's the correct method
+        assertNotNull(method);
+        assertEquals("privateMethod", method.getName());
+        assertEquals(0, method.getParameterCount());
+        assertTrue(method.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredMethod method with a method that has parameters.
+     */
+    @Test
+    public void testGetDeclaredMethod_MethodWithParameters() {
+        // Get method with parameters
+        Method method = ReflectionUtils.getDeclaredMethod(TestClass.class, "privateMethodWithParams", 
+                String.class, int.class);
+        
+        // Verify it's the correct method
+        assertNotNull(method);
+        assertEquals("privateMethodWithParams", method.getName());
+        assertEquals(2, method.getParameterCount());
+        assertEquals(String.class, method.getParameterTypes()[0]);
+        assertEquals(int.class, method.getParameterTypes()[1]);
+        assertTrue(method.isAccessible());
+    }
+
+    /**
+     * Test for getDeclaredMethod method when method doesn't exist.
+     */
+    @Test
+    public void testGetDeclaredMethod_NonExistentMethod() {
+        try {
+            // Try to get a method that doesn't exist
+            ReflectionUtils.getDeclaredMethod(TestClass.class, "nonExistentMethod");
+            fail("Expected PropifyException was not thrown");
+        } catch (PropifyException e) {
+            // Verify the exception message
+            assertTrue(e.getMessage().contains("Failed to get method"));
+            assertTrue(e.getCause() instanceof NoSuchMethodException);
+        }
+    }
+}

propify/src/test/java/com/vgerbot/propify/common/ReflectionUtils_MethodsTest.java

@@ -0,0 +1,41 @@
+package com.vgerbot.propify.common;
+
+import org.junit.Test;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Test for the Utils constructor to ensure it cannot be instantiated.
+ */
+public class Utils_ConstructorTest {
+
+    /**
+     * Test that the Utils constructor throws a PropifyException when attempting to instantiate it.
+     * This verifies that the utility class is properly designed to prevent instantiation.
+     */
+    @Test
+    public void testConstructor_ThrowsPropifyException() {
+        try {
+            // Get the private constructor
+            Constructor<Utils> constructor = Utils.class.getDeclaredConstructor();
+            // Make it accessible
+            constructor.setAccessible(true);
+            // Try to create a new instance
+            constructor.newInstance();
+            // If we get here, the test should fail
+            fail("Expected PropifyException was not thrown");
+        } catch (InvocationTargetException e) {
+            // The constructor should throw a PropifyException
+            Throwable cause = e.getCause();
+            assertTrue("Expected PropifyException but got: " + cause.getClass().getName(), 
+                      cause instanceof PropifyException);
+            assertEquals("Cannot instantiate Utils class", cause.getMessage());
+        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+}