test: add 5 Eclipse resource infrastructure tests

org.moreunit.core.test/test/org/moreunit/core/extension/ExtensionPointsTest.java

@@ -0,0 +1,17 @@
+package org.moreunit.core.extension;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.moreunit.core.MoreUnitCore;
+
+public class ExtensionPointsTest
+{
+    @Test
+    public void LANGUAGES_should_be_correct_extension_point_id()
+    {
+        String expected = MoreUnitCore.PLUGIN_ID + ".languages";
+
+        assertEquals(expected, ExtensionPoints.LANGUAGES);
+    }
+}

org.moreunit.core.test/test/org/moreunit/core/extension/JumperExtensionManagerTest.java

@@ -0,0 +1,124 @@
+package org.moreunit.core.extension;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.ui.IEditorPart;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.moreunit.core.extension.jump.IJumpContext;
+import org.moreunit.core.extension.jump.IJumper;
+import org.moreunit.core.extension.jump.JumpResult;
+import org.moreunit.core.log.Logger;
+
+public class JumperExtensionManagerTest
+{
+    private LanguageExtensionManager languageExtensionManager;
+    private Logger logger;
+    private JumperExtensionManager manager;
+
+    @BeforeEach
+    public void setUp()
+    {
+        languageExtensionManager = mock(LanguageExtensionManager.class);
+        logger = mock(Logger.class);
+        manager = new JumperExtensionManager(languageExtensionManager, logger);
+    }
+
+    @Test
+    public void jump_should_return_notDone_when_no_jumpers_for_extension()
+    {
+        IJumpContext context = createMockContext("java");
+
+        when(languageExtensionManager.getJumpersFor("java")).thenReturn(new Iterable<IJumper>()
+        {
+            @Override
+            public java.util.Iterator<IJumper> iterator()
+            {
+                return java.util.Collections.emptyIterator();
+            }
+        });
+
+        JumpResult result = manager.jump(context);
+
+        assertEquals(JumpResult.notDone(), result);
+    }
+
+    @Test
+    public void jump_should_return_done_when_jumper_returns_done()
+    {
+        IJumpContext context = createMockContext("java");
+        IJumper jumper = mock(IJumper.class);
+
+        when(languageExtensionManager.getJumpersFor("java")).thenReturn(() -> java.util.Collections.singleton(jumper).iterator());
+        when(jumper.jump(context)).thenReturn(JumpResult.done());
+
+        JumpResult result = manager.jump(context);
+
+        assertEquals(JumpResult.done(), result);
+    }
+
+    @Test
+    public void jump_should_stop_at_first_done_result()
+    {
+        IJumpContext context = createMockContext("java");
+        IJumper jumper1 = mock(IJumper.class);
+        IJumper jumper2 = mock(IJumper.class);
+
+        when(languageExtensionManager.getJumpersFor("java")).thenReturn(() -> java.util.Arrays.asList(jumper1, jumper2).iterator());
+        when(jumper1.jump(context)).thenReturn(JumpResult.done());
+        when(jumper2.jump(context)).thenReturn(JumpResult.notDone());
+
+        JumpResult result = manager.jump(context);
+
+        assertEquals(JumpResult.done(), result);
+        verify(jumper1).jump(context);
+        verify(jumper2).jump(context);
+    }
+
+    @Test
+    public void jump_should_return_done_when_jumper_throws_exception()
+    {
+        IJumpContext context = createMockContext("java");
+        IJumper jumper = mock(IJumper.class);
+
+        when(languageExtensionManager.getJumpersFor("java")).thenReturn(() -> java.util.Collections.singleton(jumper).iterator());
+        when(jumper.jump(context)).thenThrow(new RuntimeException("test exception"));
+
+        JumpResult result = manager.jump(context);
+
+        assertEquals(JumpResult.done(), result);
+    }
+
+    @Test
+    public void jump_should_return_done_when_jumper_returns_null()
+    {
+        IJumpContext context = createMockContext("java");
+        IJumper jumper = mock(IJumper.class);
+
+        when(languageExtensionManager.getJumpersFor("java")).thenReturn(() -> java.util.Collections.singleton(jumper).iterator());
+        when(jumper.jump(context)).thenReturn(null);
+
+        JumpResult result = manager.jump(context);
+
+        assertEquals(JumpResult.done(), result);
+    }
+
+    private IJumpContext createMockContext(String fileExtension)
+    {
+        IJumpContext context = mock(IJumpContext.class);
+        IFile file = mock(IFile.class);
+        when(file.getFileExtension()).thenReturn(fileExtension);
+        when(context.getSelectedFile()).thenReturn(file);
+        when(context.getExecutionEvent()).thenReturn(mock(ExecutionEvent.class));
+        when(context.getOpenEditorPart()).thenReturn(mock(IEditorPart.class));
+        when(context.isFileOpenInEditor()).thenReturn(false);
+        return context;
+    }
+}

org.moreunit.core.test/test/org/moreunit/core/extension/LanguageExtensionManagerTest.java

@@ -0,0 +1,212 @@
+package org.moreunit.core.extension;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Collections;
+import java.util.Iterator;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.Platform;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+
+import org.moreunit.core.languages.Language;
+import org.moreunit.core.log.Logger;
+
+public class LanguageExtensionManagerTest
+{
+    private BundleContext bundleContext;
+    private Logger logger;
+    private LanguageExtensionManager manager;
+    private IExtensionRegistry extensionRegistry;
+    private IConfigurationElement[] configElements;
+
+    @BeforeEach
+    public void setUp()
+    {
+        bundleContext = mock(BundleContext.class);
+        logger = mock(Logger.class);
+        extensionRegistry = mock(IExtensionRegistry.class);
+        configElements = new IConfigurationElement[0];
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_return_true_when_language_exists()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            IConfigurationElement configElement = mock(IConfigurationElement.class);
+            when(configElement.getAttribute("fileExtension")).thenReturn("java");
+            when(configElement.getAttribute("name")).thenReturn("Java");
+            when(configElement.getChildren("condition")).thenReturn(new IConfigurationElement[0]);
+            when(configElement.getContributor()).thenReturn(mock(org.eclipse.core.runtime.IContributor.class));
+
+            IConfigurationElement[] elements = new IConfigurationElement[] { configElement };
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(elements);
+
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertTrue(manager.extensionExistsForLanguage("java"));
+        }
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_return_false_when_language_not_exists()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(new IConfigurationElement[0]);
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertFalse(manager.extensionExistsForLanguage("nonexistent"));
+        }
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_return_false_when_dependency_not_met()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            IConfigurationElement configElement = mock(IConfigurationElement.class);
+            when(configElement.getAttribute("fileExtension")).thenReturn("java");
+            when(configElement.getAttribute("name")).thenReturn("Java");
+
+            IConfigurationElement conditionElement = mock(IConfigurationElement.class);
+            when(conditionElement.getAttribute("type")).thenReturn("dependency");
+            when(conditionElement.getAttribute("value")).thenReturn("missing.bundle");
+
+            when(configElement.getChildren("condition")).thenReturn(new IConfigurationElement[] { conditionElement });
+            when(configElement.getContributor()).thenReturn(mock(org.eclipse.core.runtime.IContributor.class));
+
+            IConfigurationElement[] elements = new IConfigurationElement[] { configElement };
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(elements);
+
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            Bundle[] bundles = new Bundle[0];
+            when(bundleContext.getBundles()).thenReturn(bundles);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertFalse(manager.extensionExistsForLanguage("java"));
+        }
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_return_true_when_dependency_met()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            IConfigurationElement configElement = mock(IConfigurationElement.class);
+            when(configElement.getAttribute("fileExtension")).thenReturn("java");
+            when(configElement.getAttribute("name")).thenReturn("Java");
+
+            IConfigurationElement conditionElement = mock(IConfigurationElement.class);
+            when(conditionElement.getAttribute("type")).thenReturn("dependency");
+            when(conditionElement.getAttribute("value")).thenReturn("org.eclipse.jdt.core");
+
+            when(configElement.getChildren("condition")).thenReturn(new IConfigurationElement[] { conditionElement });
+            when(configElement.getContributor()).thenReturn(mock(org.eclipse.core.runtime.IContributor.class));
+
+            IConfigurationElement[] elements = new IConfigurationElement[] { configElement };
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(elements);
+
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            Bundle bundle = mock(Bundle.class);
+            when(bundle.getSymbolicName()).thenReturn("org.eclipse.jdt.core");
+            Bundle[] bundles = new Bundle[] { bundle };
+            when(bundleContext.getBundles()).thenReturn(bundles);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertTrue(manager.extensionExistsForLanguage("java"));
+        }
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_ignore_unknown_condition_types()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            IConfigurationElement configElement = mock(IConfigurationElement.class);
+            when(configElement.getAttribute("fileExtension")).thenReturn("java");
+            when(configElement.getAttribute("name")).thenReturn("Java");
+
+            IConfigurationElement conditionElement = mock(IConfigurationElement.class);
+            when(conditionElement.getAttribute("type")).thenReturn("unknown");
+            when(conditionElement.getAttribute("value")).thenReturn("some.value");
+
+            when(configElement.getChildren("condition")).thenReturn(new IConfigurationElement[] { conditionElement });
+            when(configElement.getContributor()).thenReturn(mock(org.eclipse.core.runtime.IContributor.class));
+
+            IConfigurationElement[] elements = new IConfigurationElement[] { configElement };
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(elements);
+
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertTrue(manager.extensionExistsForLanguage("java"));
+        }
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_handle_null_conditions()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            IConfigurationElement configElement = mock(IConfigurationElement.class);
+            when(configElement.getAttribute("fileExtension")).thenReturn("java");
+            when(configElement.getAttribute("name")).thenReturn("Java");
+            when(configElement.getChildren("condition")).thenReturn(null);
+            when(configElement.getContributor()).thenReturn(mock(org.eclipse.core.runtime.IContributor.class));
+
+            IConfigurationElement[] elements = new IConfigurationElement[] { configElement };
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(elements);
+
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertTrue(manager.extensionExistsForLanguage("java"));
+        }
+    }
+
+    @Test
+    public void extensionExistsForLanguage_should_log_warn_on_exception()
+    {
+        try (MockedStatic<Platform> platformMock = Mockito.mockStatic(Platform.class))
+        {
+            IConfigurationElement configElement = mock(IConfigurationElement.class);
+            when(configElement.getAttribute("fileExtension")).thenThrow(new RuntimeException("test error"));
+            when(configElement.getContributor()).thenReturn(mock(org.eclipse.core.runtime.IContributor.class));
+
+            IConfigurationElement[] elements = new IConfigurationElement[] { configElement };
+            when(extensionRegistry.getConfigurationElementsFor(ExtensionPoints.LANGUAGES)).thenReturn(elements);
+
+            platformMock.when(Platform::getExtensionRegistry).thenReturn(extensionRegistry);
+
+            manager = new LanguageExtensionManager(bundleContext, logger);
+
+            assertFalse(manager.extensionExistsForLanguage("java"));
+            verify(logger).warn(anyString());
+        }
+    }
+}