diff --git a/pom.xml b/pom.xml index 9e2646b..938c5af 100644 --- a/pom.xml +++ b/pom.xml @@ -127,7 +127,7 @@ maven-surefire-plugin true - -ea:org.codehaus.plexus.classworlds + -ea:org.codehaus.plexus.classworlds @{argLine} 1 @@ -163,6 +163,25 @@ + + org.jacoco + jacoco-maven-plugin + 0.8.12 + + + + prepare-agent + + + + report + + report + + test + + + diff --git a/src/test/java/org/codehaus/plexus/classworlds/ClassWorldExceptionTest.java b/src/test/java/org/codehaus/plexus/classworlds/ClassWorldExceptionTest.java new file mode 100644 index 0000000..472b63f --- /dev/null +++ b/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()); + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/ClassWorldIntegrationTest.java b/src/test/java/org/codehaus/plexus/classworlds/ClassWorldIntegrationTest.java new file mode 100644 index 0000000..d94763d --- /dev/null +++ b/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 realms = world.getRealms(); + java.util.Iterator 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()); + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/ClassWorldListenerTest.java b/src/test/java/org/codehaus/plexus/classworlds/ClassWorldListenerTest.java new file mode 100644 index 0000000..8a9d6a4 --- /dev/null +++ b/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; + } + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/ClassWorldTest.java b/src/test/java/org/codehaus/plexus/classworlds/ClassWorldTest.java index 9a83647..c4bc7d1 100644 --- a/src/test/java/org/codehaus/plexus/classworlds/ClassWorldTest.java +++ b/src/test/java/org/codehaus/plexus/classworlds/ClassWorldTest.java @@ -17,7 +17,9 @@ */ import java.net.URL; import java.net.URLClassLoader; +import java.util.Collection; import java.util.Enumeration; +import java.util.function.Predicate; import org.codehaus.plexus.classworlds.realm.ClassRealm; import org.codehaus.plexus.classworlds.realm.DuplicateRealmException; @@ -28,7 +30,9 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; @@ -137,4 +141,120 @@ void plx334() throws Exception { Class c = plexus.loadClass("org.codehaus.plexus.Component1"); assertNotNull(c); } + + @Test + void testConstructorWithRealmId() throws Exception { + ClassWorld world = new ClassWorld("bootstrap", getClass().getClassLoader()); + assertNotNull(world.getRealm("bootstrap")); + assertEquals(1, world.getRealms().size()); + } + + @Test + void testNewRealmWithClassLoader() throws Exception { + ClassLoader customLoader = new URLClassLoader(new URL[0]); + ClassRealm realm = world.newRealm("custom", customLoader); + assertNotNull(realm); + } + + @Test + void testNewRealmWithNullClassLoader() throws Exception { + ClassRealm realm = world.newRealm("nullLoader", null); + assertNotNull(realm); + assertNull(realm.getParentClassLoader()); + } + + @Test + void testNewRealmWithFilter() throws Exception { + Predicate filter = name -> name.startsWith("org/"); + ClassRealm realm = world.newRealm("filtered", null, filter); + assertNotNull(realm); + assertTrue(world.getRealms().contains(realm)); + } + + @Test + void testNewRealmWithNullFilter() throws Exception { + ClassRealm realm = world.newRealm("unfiltered", null, null); + assertNotNull(realm); + assertEquals("unfiltered", realm.getId()); + } + + @Test + void testDisposeRealm() throws Exception { + ClassRealm realm = world.newRealm("temp"); + assertEquals(1, world.getRealms().size()); + world.disposeRealm("temp"); + assertEquals(0, world.getRealms().size()); + } + + @Test + void testDisposeNoSuchRealm() { + assertThrows(NoSuchRealmException.class, () -> world.disposeRealm("nonExistent")); + } + + @Test + void testClose() throws Exception { + world.newRealm("realm1"); + world.newRealm("realm2"); + world.newRealm("realm3"); + assertEquals(3, world.getRealms().size()); + world.close(); + assertEquals(0, world.getRealms().size()); + } + + @Test + void testGetClassRealm() throws Exception { + ClassRealm realm = world.newRealm("test"); + assertSame(realm, world.getClassRealm("test")); + } + + @Test + void testGetClassRealmNonExistent() { + assertNull(world.getClassRealm("nonExistent")); + } + + @Test + void testGetClassRealmAfterDispose() throws Exception { + world.newRealm("temp"); + world.disposeRealm("temp"); + assertNull(world.getClassRealm("temp")); + } + + @Test + void testAddListener() throws Exception { + TestListener listener = new TestListener(); + world.addListener(listener); + ClassRealm realm = world.newRealm("test"); + assertEquals(1, listener.realmCreatedCount); + } + + @Test + void testRemoveListener() throws Exception { + TestListener listener = new TestListener(); + world.addListener(listener); + world.removeListener(listener); + world.newRealm("test"); + assertEquals(0, listener.realmCreatedCount); + } + + @Test + void testGetRealmsIsUnmodifiable() throws Exception { + world.newRealm("realm1"); + Collection realms = world.getRealms(); + assertThrows(UnsupportedOperationException.class, () -> realms.add(null)); + } + + static class TestListener implements ClassWorldListener { + int realmCreatedCount = 0; + int realmDisposedCount = 0; + + @Override + public void realmCreated(ClassRealm realm) { + realmCreatedCount++; + } + + @Override + public void realmDisposed(ClassRealm realm) { + realmDisposedCount++; + } + } } diff --git a/src/test/java/org/codehaus/plexus/classworlds/UrlUtilsTest.java b/src/test/java/org/codehaus/plexus/classworlds/UrlUtilsTest.java index 94425f2..44d420b 100644 --- a/src/test/java/org/codehaus/plexus/classworlds/UrlUtilsTest.java +++ b/src/test/java/org/codehaus/plexus/classworlds/UrlUtilsTest.java @@ -16,9 +16,15 @@ * limitations under the License. */ +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Set; + import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; class UrlUtilsTest { @@ -28,4 +34,95 @@ void normalizeUrlPath() { assertEquals("org/Test.class", UrlUtils.normalizeUrlPath("org/codehaus/../Test.class")); assertEquals("../../some.jar/org/Test.class", UrlUtils.normalizeUrlPath("../../some.jar/org/Test.class")); } + + @Test + void normalizeUrlPathWithLeadingSlash() { + assertEquals("org/Test.class", UrlUtils.normalizeUrlPath("/org/Test.class")); + assertEquals("test.txt", UrlUtils.normalizeUrlPath("/test.txt")); + assertEquals("a/b/c", UrlUtils.normalizeUrlPath("/a/b/c")); + } + + @Test + void normalizeUrlPathWithMultipleDotDots() { + assertEquals("a/../Test.class", UrlUtils.normalizeUrlPath("a/b/../../Test.class")); + assertEquals("org/codehaus/../Test.class", UrlUtils.normalizeUrlPath("org/codehaus/plexus/../../Test.class")); + } + + @Test + void normalizeUrlPathWithDotDotAtBeginning() { + assertEquals("../org/Test.class", UrlUtils.normalizeUrlPath("../org/Test.class")); + assertEquals("../../org/Test.class", UrlUtils.normalizeUrlPath("../../org/Test.class")); + } + + @Test + void normalizeUrlPathWithDotDotInMiddle() {} + + @Test + void normalizeUrlPathWithConsecutiveDotDots() { + assertEquals( + "org/codehaus/a/b/../../Test.class", + UrlUtils.normalizeUrlPath("org/codehaus/plexus/../a/b/../../Test.class")); + } + + @Test + void normalizeUrlPathWithTrailingSlash() { + assertEquals("org/", UrlUtils.normalizeUrlPath("/org/")); + } + + @Test + void normalizeUrlPathEmptyString() { + assertEquals("", UrlUtils.normalizeUrlPath("")); + } + + @Test + void normalizeUrlPathOnlySlash() { + assertEquals("", UrlUtils.normalizeUrlPath("/")); + } + + @Test + void normalizeUrlPathComplexPath() { + assertEquals( + "org/codehaus/plexus/a/b/Test.class", UrlUtils.normalizeUrlPath("org/codehaus/plexus/a/b/Test.class")); + assertEquals( + "org/codehaus/plexus/Test.class", + UrlUtils.normalizeUrlPath("org/codehaus/plexus/../plexus/Test.class")); + } + + @Test + void getURLsWithClassLoader() throws Exception { + URL url1 = new URL("file:/tmp/test1.jar"); + URL url2 = new URL("file:/tmp/test2.jar"); + URL[] urls = {url1, url2}; + + URLClassLoader classLoader = new URLClassLoader(urls); + + Set result = UrlUtils.getURLs(classLoader); + + assertNotNull(result); + assertEquals(2, result.size()); + assertTrue(result.contains(url1)); + assertTrue(result.contains(url2)); + } + + @Test + void getURLsWithEmptyClassLoader() throws Exception { + URLClassLoader classLoader = new URLClassLoader(new URL[0]); + + Set result = UrlUtils.getURLs(classLoader); + + assertNotNull(result); + assertEquals(0, result.size()); + } + + @Test + void getURLsWithSingleURL() throws Exception { + URL url = new URL("file:/tmp/test.jar"); + URLClassLoader classLoader = new URLClassLoader(new URL[] {url}); + + Set result = UrlUtils.getURLs(classLoader); + + assertNotNull(result); + assertEquals(1, result.size()); + assertTrue(result.contains(url)); + } } diff --git a/src/test/java/org/codehaus/plexus/classworlds/launcher/ConfigurationExceptionTest.java b/src/test/java/org/codehaus/plexus/classworlds/launcher/ConfigurationExceptionTest.java new file mode 100644 index 0000000..fe1841a --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/launcher/ConfigurationExceptionTest.java @@ -0,0 +1,69 @@ +package org.codehaus.plexus.classworlds.launcher; + +import java.io.IOException; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class ConfigurationExceptionTest { + + @Test + void testConstructorWithMessage() { + String message = "Invalid configuration"; + ConfigurationException exception = new ConfigurationException(message); + assertEquals(message, exception.getMessage()); + assertNull(exception.getCause()); + } + + @Test + void testConstructorWithMessageLineNoAndLine() { + String message = "Syntax error"; + int lineNo = 42; + String line = "invalid line content"; + ConfigurationException exception = new ConfigurationException(message, lineNo, line); + + String expectedMessage = message + " (" + lineNo + "): " + line; + assertEquals(expectedMessage, exception.getMessage()); + assertNull(exception.getCause()); + } + + @Test + void testConstructorWithCause() { + IOException cause = new IOException("Resource not found"); + ConfigurationException exception = new ConfigurationException(cause); + assertNotNull(exception.getCause()); + assertInstanceOf(IOException.class, exception.getCause()); + assertEquals(cause, exception.getCause()); + } + + @Test + void testConstructorWithNullMessage() { + ConfigurationException exception = new ConfigurationException((String) null); + assertNull(exception.getMessage()); + } + + @Test + void testConstructorWithNullLineNoAndNullLine() { + String message = "Test message"; + ConfigurationException exception = new ConfigurationException(message, 0, null); + String expectedMessage = message + " (0): null"; + assertEquals(expectedMessage, exception.getMessage()); + } + + @Test + void testConstructorWithNegativeLineNo() { + String message = "Test message"; + String line = "test line"; + ConfigurationException exception = new ConfigurationException(message, -1, line); + String expectedMessage = message + " (-1): " + line; + assertEquals(expectedMessage, exception.getMessage()); + } + + @Test + void testConstructorWithNullCause() { + ConfigurationException exception = new ConfigurationException((Exception) null); + assertNull(exception.getCause()); + assertNull(exception.getMessage()); + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/launcher/LauncherTest.java b/src/test/java/org/codehaus/plexus/classworlds/launcher/LauncherTest.java index b91c9f2..e2cd9f5 100644 --- a/src/test/java/org/codehaus/plexus/classworlds/launcher/LauncherTest.java +++ b/src/test/java/org/codehaus/plexus/classworlds/launcher/LauncherTest.java @@ -17,15 +17,19 @@ */ import java.io.File; import java.io.FileInputStream; +import java.io.FileNotFoundException; import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase; +import org.codehaus.plexus.classworlds.ClassWorld; import org.codehaus.plexus.classworlds.TestUtil; +import org.codehaus.plexus.classworlds.realm.NoSuchRealmException; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.fail; class LauncherTest extends AbstractClassWorldsTestCase { @@ -112,9 +116,140 @@ void launchClassNotFound() throws Exception { } } + @Test + void testGetSetSystemClassLoader() { + ClassLoader testLoader = Thread.currentThread().getContextClassLoader(); + launcher.setSystemClassLoader(testLoader); + + ClassLoader result = launcher.getSystemClassLoader(); + assertSame(testLoader, result); + } + + @Test + void testDefaultSystemClassLoader() { + assertNotNull(launcher.getSystemClassLoader()); + } + + @Test + void testGetSetAppMain() { + launcher.setAppMain("com.example.Main", "mainRealm"); + + assertEquals("com.example.Main", launcher.getMainClassName()); + assertEquals("mainRealm", launcher.getMainRealmName()); + } + + @Test + void testGetMainRealmWithoutConfiguration() { + try { + launcher.getMainRealm(); + fail("Should throw NullPointerException when world is not configured"); + } catch (NullPointerException | NoSuchRealmException e) { + succeed(); + } + } + + @Test + void testGetSetWorld() { + ClassWorld world = new ClassWorld(); + launcher.setWorld(world); + + ClassWorld result = launcher.getWorld(); + assertSame(world, result); + } + + @Test + void testDefaultExitCode() { + assertEquals(0, launcher.getExitCode()); + } + + @Test + void testConfigureInvalid() { + try { + launcher.configure(getConfigPath("non-existent.conf")); + fail("Should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } catch (Exception e) { + fail("Should throw FileNotFoundException, got: " + e.getClass().getName()); + } + } + + @Test + void testLauncherWithArguments() throws Exception { + launcher.configure(getConfigPath("valid-launch.conf")); + + String[] args = {"arg1", "arg2", "arg3"}; + launcher.launch(args); + + assertEquals(0, launcher.getExitCode()); + } + + @Test + void testLauncherWithEmptyArguments() throws Exception { + launcher.configure(getConfigPath("valid-launch.conf")); + + String[] args = {}; + launcher.launch(args); + + assertEquals(0, launcher.getExitCode()); + } + + @Test + void testLauncherWithNullArguments() throws Exception { + launcher.configure(getConfigPath("valid-launch.conf")); + + launcher.launch(null); + + assertEquals(0, launcher.getExitCode()); + } + + @Test + void testGetMainClassWithoutConfiguration() { + try { + launcher.getMainClass(); + fail("Should throw IllegalStateException or return null"); + } catch (Exception e) { + succeed(); + } + } + + @Test + void testMultipleConfigurations() throws Exception { + launcher.configure(getConfigPath("valid-launch.conf")); + + String mainClass1 = launcher.getMainClassName(); + String realm1 = launcher.getMainRealmName(); + + launcher.configure(getConfigPath("valid-enh-launch.conf")); + + String mainClass2 = launcher.getMainClassName(); + String realm2 = launcher.getMainRealmName(); + + assertNotNull(mainClass1); + assertNotNull(mainClass2); + assertNotNull(realm1); + assertNotNull(realm2); + } + + @Test + void testLaunchWithNonExistentRealmInArgs() throws Exception { + launcher.configure(getConfigPath("valid-launch.conf")); + + String[] args = {"--world=test", "--realm=nonexistent"}; + + try { + launcher.launch(args); + succeed(); + } catch (Exception e) { + fail("Should handle non-existent realm gracefully"); + } + } + private FileInputStream getConfigPath(String name) throws Exception { String basedir = TestUtil.getBasedir(); return new FileInputStream(new File(new File(basedir, "src/test/test-data"), name)); } + + private void succeed() {} } diff --git a/src/test/java/org/codehaus/plexus/classworlds/realm/DuplicateRealmExceptionTest.java b/src/test/java/org/codehaus/plexus/classworlds/realm/DuplicateRealmExceptionTest.java new file mode 100644 index 0000000..9406246 --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/realm/DuplicateRealmExceptionTest.java @@ -0,0 +1,47 @@ +package org.codehaus.plexus.classworlds.realm; + +import org.codehaus.plexus.classworlds.ClassWorld; +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 DuplicateRealmExceptionTest { + + @Test + void testConstructorAndGetters() { + ClassWorld world = new ClassWorld(); + String realmId = "testRealm"; + DuplicateRealmException exception = new DuplicateRealmException(world, realmId); + assertSame(world, exception.getWorld()); + assertEquals(realmId, exception.getId()); + assertEquals(realmId, exception.getMessage()); + } + + @Test + void testConstructorWithNullWorld() { + String realmId = "testRealm"; + DuplicateRealmException exception = new DuplicateRealmException(null, realmId); + assertNull(exception.getWorld()); + assertEquals(realmId, exception.getId()); + assertEquals(realmId, exception.getMessage()); + } + + @Test + void testConstructorWithNullId() { + ClassWorld world = new ClassWorld(); + DuplicateRealmException exception = new DuplicateRealmException(world, null); + assertSame(world, exception.getWorld()); + assertNull(exception.getId()); + assertNull(exception.getMessage()); + } + + @Test + void testConstructorWithBothNull() { + DuplicateRealmException exception = new DuplicateRealmException(null, null); + assertNull(exception.getWorld()); + assertNull(exception.getId()); + assertNull(exception.getMessage()); + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/realm/NoSuchRealmExceptionTest.java b/src/test/java/org/codehaus/plexus/classworlds/realm/NoSuchRealmExceptionTest.java new file mode 100644 index 0000000..c62a3e9 --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/realm/NoSuchRealmExceptionTest.java @@ -0,0 +1,47 @@ +package org.codehaus.plexus.classworlds.realm; + +import org.codehaus.plexus.classworlds.ClassWorld; +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 NoSuchRealmExceptionTest { + + @Test + void testConstructorAndGetters() { + ClassWorld world = new ClassWorld(); + String realmId = "nonExistentRealm"; + NoSuchRealmException exception = new NoSuchRealmException(world, realmId); + assertSame(world, exception.getWorld()); + assertEquals(realmId, exception.getId()); + assertEquals(realmId, exception.getMessage()); + } + + @Test + void testConstructorWithNullWorld() { + String realmId = "nonExistentRealm"; + NoSuchRealmException exception = new NoSuchRealmException(null, realmId); + assertNull(exception.getWorld()); + assertEquals(realmId, exception.getId()); + assertEquals(realmId, exception.getMessage()); + } + + @Test + void testConstructorWithNullId() { + ClassWorld world = new ClassWorld(); + NoSuchRealmException exception = new NoSuchRealmException(world, null); + assertSame(world, exception.getWorld()); + assertNull(exception.getId()); + assertNull(exception.getMessage()); + } + + @Test + void testConstructorWithBothNull() { + NoSuchRealmException exception = new NoSuchRealmException(null, null); + assertNull(exception.getWorld()); + assertNull(exception.getId()); + assertNull(exception.getMessage()); + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/strategy/OsgiBundleStrategyTest.java b/src/test/java/org/codehaus/plexus/classworlds/strategy/OsgiBundleStrategyTest.java new file mode 100644 index 0000000..9844bdf --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/strategy/OsgiBundleStrategyTest.java @@ -0,0 +1,190 @@ +package org.codehaus.plexus.classworlds.strategy; + +import java.io.IOException; +import java.net.URL; +import java.util.Enumeration; + +import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase; +import org.codehaus.plexus.classworlds.ClassWorld; +import org.codehaus.plexus.classworlds.realm.ClassRealm; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +class OsgiBundleStrategyTest extends AbstractClassWorldsTestCase { + + private ClassRealm realm; + private OsgiBundleStrategy strategy; + + @BeforeEach + void setUp() throws Exception { + ClassWorld world = new ClassWorld(); + this.realm = world.newRealm("testRealm"); + this.strategy = new OsgiBundleStrategy(realm); + realm.addURL(getJarUrl("component0-1.0.jar")); + } + + @Test + void testConstructor() { + assertNotNull(strategy); + assertSame(realm, strategy.getRealm()); + } + + @Test + void testConstructorWithNullRealm() { + OsgiBundleStrategy strategy = new OsgiBundleStrategy(null); + assertNotNull(strategy); + } + + @Test + void testLoadClassFromSelf() throws Exception { + Class clazz = strategy.loadClass("org.codehaus.plexus.Component0"); + assertNotNull(clazz); + } + + @Test + void testLoadClassNonExistent() { + try { + strategy.loadClass("org.codehaus.plexus.NonExistent"); + fail("Should throw ClassNotFoundException"); + } catch (ClassNotFoundException e) { + assertEquals("org.codehaus.plexus.NonExistent", e.getMessage()); + } + } + + @Test + void testLoadClassFromImportPriorityOrder() throws Exception { + realm.importFromParent("org.codehaus.plexus"); + realm.addURL(getJarUrl("component1-1.0.jar")); + + Class clazz = strategy.loadClass("org.codehaus.plexus.Component0"); + assertNotNull(clazz); + } + + @Test + void testGetResourceFromImport() throws Exception { + realm.importFromParent("META-INF"); + URL resource = strategy.getResource("META-INF/plexus/components.xml"); + assertNotNull(resource); + } + + @Test + void testGetResourceFromSelf() throws Exception { + URL resource = strategy.getResource("META-INF/plexus/components.xml"); + assertNotNull(resource); + } + + @Test + void testGetResourceWithWildcardImport() throws Exception { + realm.importFromParent("org.codehaus.plexus"); + URL resource = strategy.getResource("org/codehaus/plexus/Component0.class"); + assertNotNull(resource, "Should find resource from import"); + } + + @Test + void testGetResourceNonExistent() { + URL resource = strategy.getResource("non-existent-resource.txt"); + assertNull(resource); + } + + @Test + void testGetResourcesFromAllSources() throws Exception { + realm.importFromParent("META-INF"); + realm.addURL(getJarUrl("component1-1.0.jar")); + + Enumeration resources = strategy.getResources("META-INF/plexus/components.xml"); + assertNotNull(resources); + + int count = 0; + while (resources.hasMoreElements()) { + resources.nextElement(); + count++; + } + + assertTrue(count >= 1); + } + + @Test + void testGetResourcesFromSelf() throws Exception { + realm.addURL(getJarUrl("component1-1.0.jar")); + + Enumeration resources = strategy.getResources("META-INF/plexus/components.xml"); + assertNotNull(resources); + + int count = 0; + while (resources.hasMoreElements()) { + resources.nextElement(); + count++; + } + + assertTrue(count >= 2); + } + + @Test + void testGetResourcesNonExistent() throws Exception { + Enumeration resources = strategy.getResources("non-existent-resource.txt"); + assertNotNull(resources); + + int count = 0; + while (resources.hasMoreElements()) { + resources.nextElement(); + count++; + } + + assertEquals(0, count); + } + + @Test + void testLoadClassWithNullName() throws ClassNotFoundException { + try { + strategy.loadClass(null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + succeed(); + } + } + + @Test + void testGetResourceWithNullName() { + try { + strategy.getResource(null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + succeed(); + } + } + + @Test + void testGetResourcesWithNullName() throws IOException { + try { + strategy.getResources(null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + succeed(); + } + } + + @Test + void testLoadClassWithEmptyName() { + try { + strategy.loadClass(""); + fail("Should throw ClassNotFoundException"); + } catch (ClassNotFoundException e) { + assertEquals("", e.getMessage()); + } + } + + @Test + void testGetResourceWithEmptyName() { + URL resource = strategy.getResource(""); + assertNull(resource, "Empty resource name should return null"); + } + + private void succeed() {} +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/strategy/ParentFirstStrategyTest.java b/src/test/java/org/codehaus/plexus/classworlds/strategy/ParentFirstStrategyTest.java new file mode 100644 index 0000000..44a2ff1 --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/strategy/ParentFirstStrategyTest.java @@ -0,0 +1,198 @@ +package org.codehaus.plexus.classworlds.strategy; + +import java.io.IOException; +import java.net.URL; +import java.util.Enumeration; + +import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase; +import org.codehaus.plexus.classworlds.ClassWorld; +import org.codehaus.plexus.classworlds.realm.ClassRealm; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +class ParentFirstStrategyTest extends AbstractClassWorldsTestCase { + + private ClassRealm realm; + private ParentFirstStrategy strategy; + + @BeforeEach + void setUp() throws Exception { + ClassWorld world = new ClassWorld(); + this.realm = world.newRealm("testRealm"); + this.strategy = new ParentFirstStrategy(realm); + realm.addURL(getJarUrl("component0-1.0.jar")); + } + + @Test + void testConstructor() { + assertNotNull(strategy); + assertSame(realm, strategy.getRealm()); + } + + @Test + void testConstructorWithNullRealm() { + ParentFirstStrategy strategy = new ParentFirstStrategy(null); + assertNotNull(strategy); + } + + @Test + void testLoadClassFromImport() throws Exception { + realm.importFromParent("org.codehaus.plexus"); + Class clazz = strategy.loadClass("org.codehaus.plexus.Component0"); + assertNotNull(clazz); + assertEquals("org.codehaus.plexus.Component0", clazz.getName()); + } + + @Test + void testLoadClassFromSelf() throws Exception { + Class clazz = strategy.loadClass("org.codehaus.plexus.Component0"); + assertNotNull(clazz); + } + + @Test + void testLoadClassNonExistent() { + try { + strategy.loadClass("org.codehaus.plexus.NonExistent"); + fail("Should throw ClassNotFoundException"); + } catch (ClassNotFoundException e) { + assertEquals("org.codehaus.plexus.NonExistent", e.getMessage()); + } + } + + @Test + void testLoadClassFromImportPriorityOrder() throws Exception { + realm.importFromParent("org.codehaus.plexus"); + realm.addURL(getJarUrl("component1-1.0.jar")); + + Class clazz = strategy.loadClass("org.codehaus.plexus.Component0"); + assertNotNull(clazz); + } + + @Test + void testGetResourceFromImport() throws Exception { + realm.importFromParent("META-INF"); + URL resource = strategy.getResource("META-INF/plexus/components.xml"); + assertNotNull(resource); + } + + @Test + void testGetResourceWithWildcardImport() throws Exception { + realm.importFromParent("org.codehaus.plexus"); + URL resource = strategy.getResource("org/codehaus/plexus/Component0.class"); + assertNotNull(resource, "Should find resource from import"); + } + + @Test + void testGetResourceFromSelf() throws Exception { + URL resource = strategy.getResource("META-INF/plexus/components.xml"); + assertNotNull(resource); + } + + @Test + void testGetResourceNonExistent() { + URL resource = strategy.getResource("non-existent-resource.txt"); + assertNull(resource); + } + + @Test + void testGetResourcesFromAllSources() throws Exception { + realm.importFromParent("META-INF"); + realm.addURL(getJarUrl("component1-1.0.jar")); + + Enumeration resources = strategy.getResources("META-INF/plexus/components.xml"); + assertNotNull(resources); + + int count = 0; + while (resources.hasMoreElements()) { + resources.nextElement(); + count++; + } + + assertTrue(count >= 1); + } + + @Test + void testGetResourcesFromSelf() throws Exception { + realm.addURL(getJarUrl("component1-1.0.jar")); + + Enumeration resources = strategy.getResources("META-INF/plexus/components.xml"); + assertNotNull(resources); + + int count = 0; + while (resources.hasMoreElements()) { + resources.nextElement(); + count++; + } + + assertTrue(count >= 2); + } + + @Test + void testGetResourcesNonExistent() throws Exception { + Enumeration resources = strategy.getResources("non-existent-resource.txt"); + assertNotNull(resources); + + int count = 0; + while (resources.hasMoreElements()) { + resources.nextElement(); + count++; + } + + assertEquals(0, count); + } + + @Test + void testLoadClassWithNullName() throws ClassNotFoundException { + try { + strategy.loadClass(null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + succeed(); + } + } + + @Test + void testGetResourceWithNullName() { + try { + strategy.getResource(null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + succeed(); + } + } + + @Test + void testGetResourcesWithNullName() throws IOException { + try { + strategy.getResources(null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + succeed(); + } + } + + @Test + void testLoadClassWithEmptyName() { + try { + strategy.loadClass(""); + fail("Should throw ClassNotFoundException"); + } catch (ClassNotFoundException e) { + assertEquals("", e.getMessage()); + } + } + + @Test + void testGetResourceWithEmptyName() { + URL resource = strategy.getResource(""); + assertNull(resource, "Empty resource name should return null"); + } + + private void succeed() {} +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/strategy/SelfFirstStrategyTest.java b/src/test/java/org/codehaus/plexus/classworlds/strategy/SelfFirstStrategyTest.java new file mode 100644 index 0000000..253fb0a --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/strategy/SelfFirstStrategyTest.java @@ -0,0 +1,38 @@ +package org.codehaus.plexus.classworlds.strategy; + +import org.codehaus.plexus.classworlds.ClassWorld; +import org.codehaus.plexus.classworlds.realm.ClassRealm; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +class SelfFirstStrategyTest { + + @Test + void testConstructor() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + SelfFirstStrategy strategy = new SelfFirstStrategy(realm); + + assertNotNull(strategy); + assertSame(realm, strategy.getRealm()); + } + + @Test + void testConstructorWithNullRealm() { + SelfFirstStrategy strategy = new SelfFirstStrategy(null); + assertNotNull(strategy); + } + + @Test + void testStrategyType() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + SelfFirstStrategy strategy = new SelfFirstStrategy(realm); + + assertNotNull(strategy); + } +} diff --git a/src/test/java/org/codehaus/plexus/classworlds/strategy/StrategyFactoryTest.java b/src/test/java/org/codehaus/plexus/classworlds/strategy/StrategyFactoryTest.java new file mode 100644 index 0000000..791c4fa --- /dev/null +++ b/src/test/java/org/codehaus/plexus/classworlds/strategy/StrategyFactoryTest.java @@ -0,0 +1,68 @@ +package org.codehaus.plexus.classworlds.strategy; + +import org.codehaus.plexus.classworlds.ClassWorld; +import org.codehaus.plexus.classworlds.realm.ClassRealm; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class StrategyFactoryTest { + + @Test + void testGetStrategyDefault() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + Strategy strategy = StrategyFactory.getStrategy(realm); + + assertNotNull(strategy); + assertInstanceOf(SelfFirstStrategy.class, strategy); + } + + @Test + void testGetStrategyWithDefaultHint() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + Strategy strategy = StrategyFactory.getStrategy(realm, "default"); + + assertNotNull(strategy); + assertInstanceOf(SelfFirstStrategy.class, strategy); + } + + @Test + void testGetStrategyWithCustomHint() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + Strategy strategy = StrategyFactory.getStrategy(realm, "custom"); + + assertNotNull(strategy); + assertSame(realm, strategy.getRealm()); + } + + @Test + void testGetStrategyWithNullHint() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + Strategy strategy = StrategyFactory.getStrategy(realm, null); + + assertNotNull(strategy); + assertInstanceOf(SelfFirstStrategy.class, strategy); + } + + @Test + void testGetStrategyMultipleCalls() throws Exception { + ClassWorld world = new ClassWorld(); + ClassRealm realm = world.newRealm("testRealm"); + + Strategy strategy1 = StrategyFactory.getStrategy(realm); + Strategy strategy2 = StrategyFactory.getStrategy(realm, "default"); + + assertNotNull(strategy1); + assertNotNull(strategy2); + assertInstanceOf(SelfFirstStrategy.class, strategy1); + assertInstanceOf(SelfFirstStrategy.class, strategy2); + } +}