Add comprehensive test coverage improvements

pom.xml

@@ -127,7 +127,7 @@
         <artifactId>maven-surefire-plugin</artifactId>
         <configuration>
           <redirectTestOutputToFile>true</redirectTestOutputToFile>
-          <argLine>-ea:org.codehaus.plexus.classworlds</argLine>
+          <argLine>-ea:org.codehaus.plexus.classworlds @{argLine}</argLine>
           <forkCount>1</forkCount>
         </configuration>
       </plugin>
@@ -163,6 +163,25 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.jacoco</groupId>
+        <artifactId>jacoco-maven-plugin</artifactId>
+        <version>0.8.12</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>prepare-agent</goal>
+            </goals>
+          </execution>
+          <execution>
+            <id>report</id>
+            <goals>
+              <goal>report</goal>
+            </goals>
+            <phase>test</phase>
+          </execution>
+        </executions>
+      </plugin>
     </plugins>
   </build>
 

src/test/java/org/codehaus/plexus/classworlds/ClassWorldExceptionTest.java

@@ -0,0 +1,41 @@
+package org.codehaus.plexus.classworlds;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+class ClassWorldExceptionTest {
+
+    @Test
+    void testConstructorWithWorld() {
+        ClassWorld world = new ClassWorld();
+        ClassWorldException exception = new ClassWorldException(world);
+        assertSame(world, exception.getWorld());
+        assertNull(exception.getMessage());
+    }
+
+    @Test
+    void testConstructorWithWorldAndMessage() {
+        ClassWorld world = new ClassWorld();
+        String message = "Test exception message";
+        ClassWorldException exception = new ClassWorldException(world, message);
+        assertSame(world, exception.getWorld());
+        assertEquals(message, exception.getMessage());
+    }
+
+    @Test
+    void testConstructorWithNullWorldAndNullMessage() {
+        ClassWorldException exception = new ClassWorldException(null, null);
+        assertNull(exception.getWorld());
+        assertNull(exception.getMessage());
+    }
+
+    @Test
+    void testConstructorWithNullWorld() {
+        ClassWorldException exception = new ClassWorldException(null);
+        assertNull(exception.getWorld());
+        assertNull(exception.getMessage());
+    }
+}

src/test/java/org/codehaus/plexus/classworlds/ClassWorldIntegrationTest.java

@@ -0,0 +1,122 @@
+package org.codehaus.plexus.classworlds;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Collection;
+
+import org.codehaus.plexus.classworlds.realm.ClassRealm;
+import org.codehaus.plexus.classworlds.realm.DuplicateRealmException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ClassWorldIntegrationTest {
+
+    private ClassWorld world;
+
+    @BeforeEach
+    void setUp() {
+        world = new ClassWorld();
+    }
+
+    @Test
+    void testMultipleRealmsWithSameClassLoader() throws Exception {
+        ClassLoader loader = new URLClassLoader(new URL[0]);
+        ClassRealm realm1 = world.newRealm("realm1", loader);
+        ClassRealm realm2 = world.newRealm("realm2", loader);
+
+        assertNotNull(realm1);
+        assertNotNull(realm2);
+        assertEquals(2, world.getRealms().size());
+    }
+
+    @Test
+    void testRealmOrderPreserved() throws Exception {
+        world.newRealm("realm1");
+        world.newRealm("realm2");
+        world.newRealm("realm3");
+
+        Collection<ClassRealm> realms = world.getRealms();
+        java.util.Iterator<ClassRealm> iterator = realms.iterator();
+        assertEquals("realm1", iterator.next().getId());
+        assertEquals("realm2", iterator.next().getId());
+        assertEquals("realm3", iterator.next().getId());
+    }
+
+    @Test
+    void testRealmWithUnicodeId() throws Exception {
+        ClassRealm realm = world.newRealm("rälm-αβγ");
+        assertNotNull(realm);
+        assertEquals("rälm-αβγ", realm.getId());
+    }
+
+    @Test
+    void testRealmWithEmptyStringId() throws Exception {
+        ClassRealm realm = world.newRealm("");
+        assertNotNull(realm);
+        assertEquals("", realm.getId());
+    }
+
+    @Test
+    void testRealmWithSpecialCharactersId() throws Exception {
+        ClassRealm realm = world.newRealm("realm_test-123.special");
+        assertNotNull(realm);
+        assertEquals("realm_test-123.special", realm.getId());
+    }
+
+    @Test
+    void testDisposeRealmAndCreateAgain() throws Exception {
+        world.newRealm("temp");
+        world.disposeRealm("temp");
+        ClassRealm newRealm = world.newRealm("temp");
+        assertNotNull(newRealm);
+        assertEquals(1, world.getRealms().size());
+    }
+
+    @Test
+    void testCloseAndCreateNewRealms() throws Exception {
+        world.newRealm("realm1");
+        world.newRealm("realm2");
+        world.close();
+
+        assertEquals(0, world.getRealms().size());
+
+        world.newRealm("realm3");
+        assertEquals(1, world.getRealms().size());
+    }
+
+    @Test
+    void testLargeNumberOfRealms() throws Exception {
+        for (int i = 0; i < 100; i++) {
+            world.newRealm("realm" + i);
+        }
+        assertEquals(100, world.getRealms().size());
+    }
+
+    @Test
+    void testConcurrentRealmCreation() throws Exception {
+        world.newRealm("realm1");
+
+        Runnable createTask = () -> {
+            try {
+                for (int i = 0; i < 10; i++) {
+                    world.newRealm("thread-realm-" + Thread.currentThread().getId() + "-" + i);
+                }
+            } catch (DuplicateRealmException e) {
+                fail("Unexpected duplicate realm exception");
+            }
+        };
+
+        Thread thread1 = new Thread(createTask);
+        Thread thread2 = new Thread(createTask);
+
+        thread1.start();
+        thread2.start();
+
+        thread1.join();
+        thread2.join();
+
+        assertFalse(world.getRealms().isEmpty());
+    }
+}

src/test/java/org/codehaus/plexus/classworlds/ClassWorldListenerTest.java

@@ -0,0 +1,132 @@
+package org.codehaus.plexus.classworlds;
+
+import org.codehaus.plexus.classworlds.realm.ClassRealm;
+import org.codehaus.plexus.classworlds.realm.NoSuchRealmException;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class ClassWorldListenerTest {
+
+    @Test
+    void testRealmCreatedNotification() throws Exception {
+        ClassWorld world = new ClassWorld();
+        TestListener listener = new TestListener();
+        world.addListener(listener);
+
+        ClassRealm realm = world.newRealm("testRealm");
+
+        assertEquals(1, listener.realmCreatedCount);
+        assertSame(realm, listener.lastCreatedRealm);
+        assertEquals(0, listener.realmDisposedCount);
+    }
+
+    @Test
+    void testRealmDisposedNotification() throws Exception {
+        ClassWorld world = new ClassWorld();
+        TestListener listener = new TestListener();
+        world.addListener(listener);
+
+        ClassRealm realm = world.newRealm("testRealm");
+        world.disposeRealm("testRealm");
+
+        assertEquals(1, listener.realmCreatedCount);
+        assertEquals(1, listener.realmDisposedCount);
+        assertSame(realm, listener.lastDisposedRealm);
+    }
+
+    @Test
+    void testMultipleListeners() throws Exception {
+        ClassWorld world = new ClassWorld();
+        TestListener listener1 = new TestListener();
+        TestListener listener2 = new TestListener();
+
+        world.addListener(listener1);
+        world.addListener(listener2);
+
+        ClassRealm realm = world.newRealm("testRealm");
+
+        assertEquals(1, listener1.realmCreatedCount);
+        assertEquals(1, listener2.realmCreatedCount);
+        assertSame(realm, listener1.lastCreatedRealm);
+        assertSame(realm, listener2.lastCreatedRealm);
+    }
+
+    @Test
+    void testListenerNotifiedOnClose() throws Exception {
+        ClassWorld world = new ClassWorld();
+        TestListener listener = new TestListener();
+        world.addListener(listener);
+
+        world.newRealm("realm1");
+        world.newRealm("realm2");
+        world.newRealm("realm3");
+
+        assertEquals(3, listener.realmCreatedCount);
+
+        world.close();
+
+        assertEquals(3, listener.realmDisposedCount);
+    }
+
+    @Test
+    void testRemoveListener() throws Exception {
+        ClassWorld world = new ClassWorld();
+        TestListener listener = new TestListener();
+        world.addListener(listener);
+
+        ClassRealm realm1 = world.newRealm("realm1");
+        assertEquals(1, listener.realmCreatedCount);
+
+        world.removeListener(listener);
+
+        ClassRealm realm2 = world.newRealm("realm2");
+        assertEquals(1, listener.realmCreatedCount);
+        assertSame(realm1, listener.lastCreatedRealm);
+    }
+
+    @Test
+    void testAddDuplicateListener() throws Exception {
+        ClassWorld world = new ClassWorld();
+        TestListener listener = new TestListener();
+
+        world.addListener(listener);
+        world.addListener(listener);
+
+        ClassRealm realm = world.newRealm("testRealm");
+
+        assertEquals(1, listener.realmCreatedCount);
+    }
+
+    @Test
+    void testListenerWithNoSuchRealmException() {
+        ClassWorld world = new ClassWorld();
+        TestListener listener = new TestListener();
+        world.addListener(listener);
+
+        assertThrows(NoSuchRealmException.class, () -> world.disposeRealm("nonExistent"));
+
+        assertEquals(0, listener.realmDisposedCount);
+    }
+
+    static class TestListener implements ClassWorldListener {
+        int realmCreatedCount = 0;
+        int realmDisposedCount = 0;
+        ClassRealm lastCreatedRealm;
+        ClassRealm lastDisposedRealm;
+
+        @Override
+        public void realmCreated(ClassRealm realm) {
+            realmCreatedCount++;
+            lastCreatedRealm = realm;
+        }
+
+        @Override
+        public void realmDisposed(ClassRealm realm) {
+            realmDisposedCount++;
+            lastDisposedRealm = realm;
+        }
+    }
+}