From 0faed53296866b6c4e760d2f083c81954945feb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 17:38:19 +0200 Subject: [PATCH 01/10] test: add RenameDialogRunnable constructor test --- .../refactoring/RenameDialogRunnableTest.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 org.moreunit.test/test/org/moreunit/refactoring/RenameDialogRunnableTest.java diff --git a/org.moreunit.test/test/org/moreunit/refactoring/RenameDialogRunnableTest.java b/org.moreunit.test/test/org/moreunit/refactoring/RenameDialogRunnableTest.java new file mode 100644 index 00000000..cf5ea278 --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/refactoring/RenameDialogRunnableTest.java @@ -0,0 +1,31 @@ +package org.moreunit.refactoring; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IMethod; +import org.junit.jupiter.api.Test; +import org.moreunit.elements.ClassTypeFacade; + +public class RenameDialogRunnableTest +{ + @Test + public void constructor_should_store_parameters_and_create_diviner() + { + ClassTypeFacade javaFile = mock(ClassTypeFacade.class); + ICompilationUnit cu = mock(ICompilationUnit.class); + when(javaFile.getCompilationUnit()).thenReturn(cu); + + IMethod method = mock(IMethod.class); + + RenameDialogRunnable runnable = new RenameDialogRunnable(javaFile, method, "newName"); + + assertEquals(method, runnable.renamedMethod); + assertEquals("newName", runnable.newMethodName); + assertNotNull(runnable.testMethodDivinerFactory); + assertNotNull(runnable.testMethodDiviner); + } +} From beedec7064640a425496cd4e4036bd659fd842b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 17:48:00 +0200 Subject: [PATCH 02/10] test: add EclipseFolder and MethodContentProvider and RenameDialogRunnable tests --- .../core/resources/EclipseFolderTest.java | 46 +++++++++++++++++++ .../elements/MethodContentProviderTest.java | 41 +++++++++++++++++ 2 files changed, 87 insertions(+) create mode 100644 org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFolderTest.java create mode 100644 org.moreunit.test/test/org/moreunit/elements/MethodContentProviderTest.java diff --git a/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFolderTest.java b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFolderTest.java new file mode 100644 index 00000000..b36dc3ed --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFolderTest.java @@ -0,0 +1,46 @@ +package org.moreunit.core.resources; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.eclipse.core.resources.IFolder; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.IPath; +import org.junit.jupiter.api.Test; + +public class EclipseFolderTest +{ + @Test + public void should_create_folder_from_ifolder() + { + IFolder ifolder = mock(IFolder.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(ifolder.getFullPath()).thenReturn(path); + + IProject project = mock(IProject.class); + when(ifolder.getProject()).thenReturn(project); + + EclipseFolder folder = new EclipseFolder(ifolder); + + assertNotNull(folder.getPath()); + } + + @Test + public void get_project_should_return_eclipse_project() + { + IFolder ifolder = mock(IFolder.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(ifolder.getFullPath()).thenReturn(path); + + IProject project = mock(IProject.class); + when(project.getFullPath()).thenReturn(path); + when(ifolder.getProject()).thenReturn(project); + + EclipseFolder folder = new EclipseFolder(ifolder); + + assertNotNull(folder.getProject()); + } +} diff --git a/org.moreunit.test/test/org/moreunit/elements/MethodContentProviderTest.java b/org.moreunit.test/test/org/moreunit/elements/MethodContentProviderTest.java new file mode 100644 index 00000000..9bbe7939 --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/elements/MethodContentProviderTest.java @@ -0,0 +1,41 @@ +package org.moreunit.elements; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; + +import java.util.List; + +import org.eclipse.jdt.core.IMethod; +import org.junit.jupiter.api.Test; + +public class MethodContentProviderTest +{ + @Test + public void should_return_methods_as_elements() + { + IMethod method = mock(IMethod.class); + MethodContentProvider provider = new MethodContentProvider(List.of(method)); + + Object[] elements = provider.getElements(null); + + assertEquals(1, elements.length); + assertNotNull(elements[0]); + } + + @Test + public void should_return_empty_array_for_empty_list() + { + MethodContentProvider provider = new MethodContentProvider(List.of()); + + assertEquals(0, provider.getElements(null).length); + } + + @Test + public void dispose_and_input_changed_should_not_throw() + { + MethodContentProvider provider = new MethodContentProvider(List.of()); + provider.dispose(); + provider.inputChanged(null, null, null); + } +} From 1b2f3cd91605ef1477fff5cf34717ec0f979340f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 21:47:53 +0200 Subject: [PATCH 03/10] test: add FileMatcher, SeparatorElement and TestTypeConstants tests --- .../core/matching/FileMatcherTest.java | 22 ++++++++++++ .../preferences/TestTypeConstantsTest.java | 32 +++++++++++++++++ .../org/moreunit/ui/SeparatorElementTest.java | 35 +++++++++++++++++++ 3 files changed, 89 insertions(+) create mode 100644 org.moreunit.core.test/test/org/moreunit/core/matching/FileMatcherTest.java create mode 100644 org.moreunit.test/test/org/moreunit/preferences/TestTypeConstantsTest.java create mode 100644 org.moreunit.test/test/org/moreunit/ui/SeparatorElementTest.java diff --git a/org.moreunit.core.test/test/org/moreunit/core/matching/FileMatcherTest.java b/org.moreunit.core.test/test/org/moreunit/core/matching/FileMatcherTest.java new file mode 100644 index 00000000..56efec9c --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/matching/FileMatcherTest.java @@ -0,0 +1,22 @@ +package org.moreunit.core.matching; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; + +import org.junit.jupiter.api.Test; +import org.moreunit.core.resources.SrcFile; + +public class FileMatcherTest +{ + @Test + public void should_create_from_src_file_search_engine_and_selector() + { + SrcFile srcFile = mock(SrcFile.class); + SearchEngine searchEngine = mock(SearchEngine.class); + FileMatchSelector matchSelector = mock(FileMatchSelector.class); + + FileMatcher matcher = new FileMatcher(srcFile, searchEngine, matchSelector); + + assertNotNull(matcher); + } +} diff --git a/org.moreunit.test/test/org/moreunit/preferences/TestTypeConstantsTest.java b/org.moreunit.test/test/org/moreunit/preferences/TestTypeConstantsTest.java new file mode 100644 index 00000000..15717891 --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/preferences/TestTypeConstantsTest.java @@ -0,0 +1,32 @@ +package org.moreunit.preferences; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +public class TestTypeConstantsTest +{ + @Test + public void should_have_junit5_test_annotation() + { + assertEquals("org.junit.jupiter.api.Test", TestTypeConstants.TEST_ANNOTATION.get(PreferenceConstants.TEST_TYPE_VALUE_JUNIT_5)); + } + + @Test + public void should_have_junit4_test_annotation() + { + assertEquals("org.junit.Test", TestTypeConstants.TEST_ANNOTATION.get(PreferenceConstants.TEST_TYPE_VALUE_JUNIT_4)); + } + + @Test + public void should_have_testng_test_annotation() + { + assertEquals("org.testng.annotations.Test", TestTypeConstants.TEST_ANNOTATION.get(PreferenceConstants.TEST_TYPE_VALUE_TESTNG)); + } + + @Test + public void should_have_junit5_static_import_base() + { + assertEquals("org.junit.jupiter.api.Assertions", TestTypeConstants.STATIC_IMPORT_BASE_CLASS.get(PreferenceConstants.TEST_TYPE_VALUE_JUNIT_5)); + } +} diff --git a/org.moreunit.test/test/org/moreunit/ui/SeparatorElementTest.java b/org.moreunit.test/test/org/moreunit/ui/SeparatorElementTest.java new file mode 100644 index 00000000..77da5dfb --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/ui/SeparatorElementTest.java @@ -0,0 +1,35 @@ +package org.moreunit.ui; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +public class SeparatorElementTest +{ + @Test + public void should_not_provide_element() + { + assertFalse(new SeparatorElement().provideElement()); + } + + @Test + public void should_throw_on_execute() + { + assertThrows(UnsupportedOperationException.class, () -> new SeparatorElement().execute()); + } + + @Test + public void should_have_no_image() + { + assertNull(new SeparatorElement().getImage()); + } + + @Test + public void should_have_separator_text() + { + assertEquals("_________________", new SeparatorElement().getText()); + } +} From 3d64925682c28e69acde745b305c19d7ed708f80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 21:51:59 +0200 Subject: [PATCH 04/10] test: add XmlTemplateDefinitionReader, FileMatcher, SeparatorElement and TestTypeConstants tests --- .../XmlTemplateDefinitionReaderTest.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 org.moreunit.mock.test/test/org/moreunit/mock/templates/XmlTemplateDefinitionReaderTest.java diff --git a/org.moreunit.mock.test/test/org/moreunit/mock/templates/XmlTemplateDefinitionReaderTest.java b/org.moreunit.mock.test/test/org/moreunit/mock/templates/XmlTemplateDefinitionReaderTest.java new file mode 100644 index 00000000..4070f9d2 --- /dev/null +++ b/org.moreunit.mock.test/test/org/moreunit/mock/templates/XmlTemplateDefinitionReaderTest.java @@ -0,0 +1,48 @@ +package org.moreunit.mock.templates; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.net.URL; + +import org.junit.jupiter.api.Test; + +public class XmlTemplateDefinitionReaderTest +{ + @Test + public void should_read_valid_xml() throws Exception + { + URL xsd = getClass().getResource("/templates/mocking-templates.xsd"); + assertNotNull(xsd, "XSD resource not found"); + + XmlTemplateDefinitionReader reader = new XmlTemplateDefinitionReader(xsd); + + String validXml = "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""; + InputStream is = new ByteArrayInputStream(validXml.getBytes()); + + assertNotNull(reader.read(is)); + } + + @Test + public void should_throw_on_invalid_xml() + { + URL xsd = getClass().getResource("/templates/mocking-templates.xsd"); + assertNotNull(xsd); + + XmlTemplateDefinitionReader reader = new XmlTemplateDefinitionReader(xsd); + + String invalidXml = "not xml"; + InputStream is = new ByteArrayInputStream(invalidXml.getBytes()); + + assertThrows(MockingTemplateException.class, () -> reader.read(is)); + } +} From 7586ae5a6ebc296643b60867fe98b1c95f49695c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 21:56:58 +0200 Subject: [PATCH 05/10] test: add EclipseProject, EclipseFile, EclipsePath, ConcreteSrcFile, DefaultFileMatchSelector tests --- .../core/extension/ExtensionPointsTest.java | 17 ++ .../extension/JumperExtensionManagerTest.java | 124 ++++++++++ .../LanguageExtensionManagerTest.java | 212 ++++++++++++++++++ .../core/extension/jump/JumpResultTest.java | 41 ++++ .../DefaultFileMatchSelectorTest.java | 16 ++ .../core/resources/ConcreteSrcFileTest.java | 24 ++ .../core/resources/EclipseFileTest.java | 56 +++++ .../core/resources/EclipsePathTest.java | 52 +++++ .../core/resources/EclipseProjectTest.java | 41 ++++ .../settings/PreferencesPageSWTBotTest.java | 118 +++++++++- 10 files changed, 696 insertions(+), 5 deletions(-) create mode 100644 org.moreunit.core.test/test/org/moreunit/core/extension/ExtensionPointsTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/extension/JumperExtensionManagerTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/extension/LanguageExtensionManagerTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/extension/jump/JumpResultTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/matching/DefaultFileMatchSelectorTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/resources/ConcreteSrcFileTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFileTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/resources/EclipsePathTest.java create mode 100644 org.moreunit.core.test/test/org/moreunit/core/resources/EclipseProjectTest.java diff --git a/org.moreunit.core.test/test/org/moreunit/core/extension/ExtensionPointsTest.java b/org.moreunit.core.test/test/org/moreunit/core/extension/ExtensionPointsTest.java new file mode 100644 index 00000000..f92cbfd9 --- /dev/null +++ b/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); + } +} \ No newline at end of file diff --git a/org.moreunit.core.test/test/org/moreunit/core/extension/JumperExtensionManagerTest.java b/org.moreunit.core.test/test/org/moreunit/core/extension/JumperExtensionManagerTest.java new file mode 100644 index 00000000..e66f3fd8 --- /dev/null +++ b/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() + { + @Override + public java.util.Iterator 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; + } +} \ No newline at end of file diff --git a/org.moreunit.core.test/test/org/moreunit/core/extension/LanguageExtensionManagerTest.java b/org.moreunit.core.test/test/org/moreunit/core/extension/LanguageExtensionManagerTest.java new file mode 100644 index 00000000..edc4f51f --- /dev/null +++ b/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 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 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 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 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 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 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 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()); + } + } +} \ No newline at end of file diff --git a/org.moreunit.core.test/test/org/moreunit/core/extension/jump/JumpResultTest.java b/org.moreunit.core.test/test/org/moreunit/core/extension/jump/JumpResultTest.java new file mode 100644 index 00000000..0e5931b8 --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/extension/jump/JumpResultTest.java @@ -0,0 +1,41 @@ +package org.moreunit.core.extension.jump; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +public class JumpResultTest +{ + @Test + public void done_should_return_done_result() + { + JumpResult result = JumpResult.done(); + + assertTrue(result.isDone()); + } + + @Test + public void notDone_should_return_not_done_result() + { + JumpResult result = JumpResult.notDone(); + + assertFalse(result.isDone()); + } + + @Test + public void isDone_should_return_true_for_done_result() + { + JumpResult result = JumpResult.done(); + + assertTrue(result.isDone()); + } + + @Test + public void isDone_should_return_false_for_not_done_result() + { + JumpResult result = JumpResult.notDone(); + + assertFalse(result.isDone()); + } +} \ No newline at end of file diff --git a/org.moreunit.core.test/test/org/moreunit/core/matching/DefaultFileMatchSelectorTest.java b/org.moreunit.core.test/test/org/moreunit/core/matching/DefaultFileMatchSelectorTest.java new file mode 100644 index 00000000..1880fc15 --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/matching/DefaultFileMatchSelectorTest.java @@ -0,0 +1,16 @@ +package org.moreunit.core.matching; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; + +import org.junit.jupiter.api.Test; +import org.moreunit.core.log.Logger; + +public class DefaultFileMatchSelectorTest +{ + @Test + public void should_create_from_logger() + { + assertNotNull(new DefaultFileMatchSelector(mock(Logger.class))); + } +} diff --git a/org.moreunit.core.test/test/org/moreunit/core/resources/ConcreteSrcFileTest.java b/org.moreunit.core.test/test/org/moreunit/core/resources/ConcreteSrcFileTest.java new file mode 100644 index 00000000..6ac7cb5e --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/resources/ConcreteSrcFileTest.java @@ -0,0 +1,24 @@ +package org.moreunit.core.resources; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.runtime.IPath; +import org.junit.jupiter.api.Test; + +public class ConcreteSrcFileTest +{ + @Test + public void should_create_from_ifile() + { + IFile ifile = mock(IFile.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(ifile.getFullPath()).thenReturn(path); + + ConcreteSrcFile srcFile = new ConcreteSrcFile(new EclipseFile(ifile)); + assertNotNull(srcFile); + } +} diff --git a/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFileTest.java b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFileTest.java new file mode 100644 index 00000000..d0015259 --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseFileTest.java @@ -0,0 +1,56 @@ +package org.moreunit.core.resources; + +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.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.runtime.IPath; +import org.junit.jupiter.api.Test; + +public class EclipseFileTest +{ + @Test + public void should_create_file_from_ifile() + { + IFile ifile = mock(IFile.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(path.toString()).thenReturn("/proj/src/Foo.java"); + when(ifile.getFullPath()).thenReturn(path); + + EclipseFile file = new EclipseFile(ifile); + assertNotNull(file); + } + + @Test + public void get_extension_should_return_file_extension() + { + IFile ifile = mock(IFile.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(ifile.getFullPath()).thenReturn(path); + when(ifile.getFileExtension()).thenReturn("java"); + + EclipseFile file = new EclipseFile(ifile); + assertEquals("java", file.getExtension()); + } + + @Test + public void has_extension_should_check_file_extension() + { + IFile ifile = mock(IFile.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(ifile.getFullPath()).thenReturn(path); + when(ifile.getFileExtension()).thenReturn("java"); + + assertTrue(new EclipseFile(ifile).hasExtension()); + + when(ifile.getFileExtension()).thenReturn(null); + assertFalse(new EclipseFile(ifile).hasExtension()); + } +} diff --git a/org.moreunit.core.test/test/org/moreunit/core/resources/EclipsePathTest.java b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipsePathTest.java new file mode 100644 index 00000000..c8d184d8 --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipsePathTest.java @@ -0,0 +1,52 @@ +package org.moreunit.core.resources; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.lang.reflect.Constructor; + +import org.eclipse.core.runtime.IPath; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class EclipsePathTest +{ + private Constructor constructor; + + @BeforeEach + public void setUp() throws Exception + { + constructor = EclipsePath.class.getDeclaredConstructor(IPath.class); + constructor.setAccessible(true); + } + + @Test + public void should_wrap_ipath_and_delegate_methods() throws Exception + { + IPath ipath = mock(IPath.class); + when(ipath.removeTrailingSeparator()).thenReturn(ipath); + when(ipath.segmentCount()).thenReturn(2); + when(ipath.segment(0)).thenReturn("proj"); + when(ipath.lastSegment()).thenReturn("Foo.java"); + when(ipath.getFileExtension()).thenReturn("java"); + when(ipath.removeFileExtension()).thenReturn(ipath); + when(ipath.isEmpty()).thenReturn(false); + when(ipath.isAbsolute()).thenReturn(true); + when(ipath.toString()).thenReturn("/proj/Foo.java"); + when(ipath.segments()).thenReturn(new String[] {"proj", "Foo.java"}); + + EclipsePath path = constructor.newInstance(ipath); + + assertEquals(2, path.getSegmentCount()); + assertEquals("proj", path.getProjectName()); + assertEquals("Foo.java", path.getBaseName()); + assertEquals("java", path.getExtension()); + assertTrue(path.hasExtension()); + assertTrue(path.isAbsolute()); + assertFalse(path.isEmpty()); + assertEquals("/proj/Foo.java", path.toString()); + } +} diff --git a/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseProjectTest.java b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseProjectTest.java new file mode 100644 index 00000000..c9cf9635 --- /dev/null +++ b/org.moreunit.core.test/test/org/moreunit/core/resources/EclipseProjectTest.java @@ -0,0 +1,41 @@ +package org.moreunit.core.resources; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.lang.reflect.Constructor; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.IPath; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class EclipseProjectTest +{ + private Constructor constructor; + + @BeforeEach + public void setUp() throws Exception + { + constructor = EclipseProject.class.getDeclaredConstructor(IProject.class); + constructor.setAccessible(true); + } + + @Test + public void exists_should_check_project_and_open() throws Exception + { + IProject iproject = mock(IProject.class); + IPath path = mock(IPath.class); + when(path.removeTrailingSeparator()).thenReturn(path); + when(iproject.getFullPath()).thenReturn(path); + when(iproject.exists()).thenReturn(true); + when(iproject.isOpen()).thenReturn(true); + + assertTrue(constructor.newInstance(iproject).exists()); + + when(iproject.isOpen()).thenReturn(false); + assertFalse(constructor.newInstance(iproject).exists()); + } +} diff --git a/org.moreunit.swtbot.test/test/org/moreunit/settings/PreferencesPageSWTBotTest.java b/org.moreunit.swtbot.test/test/org/moreunit/settings/PreferencesPageSWTBotTest.java index 1c8ff4f8..a97a02ed 100644 --- a/org.moreunit.swtbot.test/test/org/moreunit/settings/PreferencesPageSWTBotTest.java +++ b/org.moreunit.swtbot.test/test/org/moreunit/settings/PreferencesPageSWTBotTest.java @@ -7,18 +7,85 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.moreunit.JavaProjectSWTBotTestHelper; +import org.moreunit.test.context.Project; +import org.moreunit.test.context.Properties; +import org.moreunit.test.context.TestType; +@Project(mainCls = "org:Dummy") @ExtendWith(SWTBotJunit5Extension.class) public class PreferencesPageSWTBotTest extends JavaProjectSWTBotTestHelper { - @Test - public void should_open_java_language_preference_page() + @org.junit.jupiter.api.BeforeEach + public void prepareWorkbench() { try { bot.shell("Preferences").close(); } catch (Exception e) { } + try + { + selectAndReturnJavaProjectFromPackageExplorer(); + } + catch (Exception e) + { + } + } + @Test + public void should_validate_pattern_field() + { + getShortcutStrategy().openPreferences(); + bot.waitUntil(shellIsActive("Preferences")); + + waitForMoreUnitInTree(); + bot.tree().expandNode("MoreUnit").select("Java"); + + // Wait for the page to load + waitForPageField(); + + // Type an invalid pattern (missing ${srcFile} variable) + bot.text(0).setText("InvalidPattern"); + waitForValidationError("The rule for naming test files must use the variable"); + + // Type a valid pattern back + bot.text(0).setText("${srcFile}Test"); + waitForValidationCleared(); + + bot.button("Cancel").click(); + } + + @Test + public void should_detect_empty_pattern() + { + getShortcutStrategy().openPreferences(); + bot.waitUntil(shellIsActive("Preferences")); + + waitForMoreUnitInTree(); + bot.tree().expandNode("MoreUnit").select("Java"); + waitForPageField(); + + // Empty pattern should show validation error + bot.text(0).setText(""); + waitForValidationError("You must enter a rule for naming test files"); + + bot.button("Cancel").click(); + } + @Test + public void should_warn_on_multiple_wildcards() + { getShortcutStrategy().openPreferences(); bot.waitUntil(shellIsActive("Preferences")); + waitForMoreUnitInTree(); + bot.tree().expandNode("MoreUnit").select("Java"); + waitForPageField(); + + // Multiple wildcards should generate a warning + bot.text(0).setText("${srcFile}*_*_Test"); + waitForWarningVisible(); + + bot.button("Cancel").click(); + } + + private void waitForMoreUnitInTree() + { bot.waitUntil(new DefaultCondition() { @Override public boolean test() { try { return bot.tree().getTreeItem("MoreUnit") != null; } @@ -28,9 +95,10 @@ public void should_open_java_language_preference_page() return "MoreUnit not found in Preferences tree"; } }, 10000); + } - bot.tree().expandNode("MoreUnit").select("Java"); - + private void waitForPageField() + { bot.waitUntil(new DefaultCondition() { @Override public boolean test() { try { return bot.label("Pattern:").isVisible(); } @@ -40,7 +108,47 @@ public void should_open_java_language_preference_page() return "Java page did not show pattern field"; } }, 10000); + } - bot.button("Cancel").click(); + private void waitForValidationError(String expectedMessage) + { + bot.waitUntil(new DefaultCondition() { + @Override public boolean test() { + try { return bot.label(expectedMessage).isVisible(); } + catch (Exception e) { return false; } + } + @Override public String getFailureMessage() { + return "Validation error did not appear: " + expectedMessage; + } + }, 5000); + } + + private void waitForValidationCleared() + { + bot.waitUntil(new DefaultCondition() { + @Override public boolean test() { + try { + bot.label("The rule for naming test files must use the variable"); + return false; + } catch (Exception e) { return true; } + } + @Override public String getFailureMessage() { + return "Validation error did not clear"; + } + }, 5000); + } + + private void waitForWarningVisible() + { + bot.waitUntil(new DefaultCondition() { + @Override public boolean test() { + try { + return bot.label("Using too many wildcards may degrade search performance and results!").isVisible(); + } catch (Exception e) { return false; } + } + @Override public String getFailureMessage() { + return "Warning about multiple wildcards did not appear"; + } + }, 5000); } } From 6a14e98a54092c0f98199b1704140c6f70b4028a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 21:58:10 +0200 Subject: [PATCH 06/10] test: add AddTestMethodContext and NamingRules tests --- .../mock/elements/NamingRulesTest.java | 29 ++++++++ .../handler/AddTestMethodContextTest.java | 66 +++++++++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 org.moreunit.mock.test/test/org/moreunit/mock/elements/NamingRulesTest.java create mode 100644 org.moreunit.test/test/org/moreunit/handler/AddTestMethodContextTest.java diff --git a/org.moreunit.mock.test/test/org/moreunit/mock/elements/NamingRulesTest.java b/org.moreunit.mock.test/test/org/moreunit/mock/elements/NamingRulesTest.java new file mode 100644 index 00000000..441230f6 --- /dev/null +++ b/org.moreunit.mock.test/test/org/moreunit/mock/elements/NamingRulesTest.java @@ -0,0 +1,29 @@ +package org.moreunit.mock.elements; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; + +import org.eclipse.jdt.core.IJavaProject; +import org.junit.jupiter.api.Test; + +public class NamingRulesTest +{ + @Test + public void should_create_with_project() + { + IJavaProject project = mock(IJavaProject.class); + NamingRules rules = new NamingRules(project); + assertNotNull(rules); + } + + @Test + public void should_clean_field_name() + { + IJavaProject project = mock(IJavaProject.class); + NamingRules rules = new NamingRules(project); + // if NamingConventions fails, this returns the original name + String result = rules.cleanFieldName("myField"); + assertEquals("myField", result); + } +} diff --git a/org.moreunit.test/test/org/moreunit/handler/AddTestMethodContextTest.java b/org.moreunit.test/test/org/moreunit/handler/AddTestMethodContextTest.java new file mode 100644 index 00000000..1ba012ad --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/handler/AddTestMethodContextTest.java @@ -0,0 +1,66 @@ +package org.moreunit.handler; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IMethod; +import org.junit.jupiter.api.Test; + +public class AddTestMethodContextTest +{ + @Test + public void two_arg_constructor_should_store_methods() + { + IMethod testMethod = mock(IMethod.class); + IMethod methodUnderTest = mock(IMethod.class); + ICompilationUnit testCu = mock(ICompilationUnit.class); + ICompilationUnit cutCu = mock(ICompilationUnit.class); + when(testMethod.getCompilationUnit()).thenReturn(testCu); + when(methodUnderTest.getCompilationUnit()).thenReturn(cutCu); + + AddTestMethodContext ctx = new AddTestMethodContext(testMethod, methodUnderTest); + + assertEquals(testCu, ctx.getTestClass()); + assertEquals(testMethod, ctx.getTestMethod()); + assertEquals(cutCu, ctx.getClassUnderTest()); + assertEquals(methodUnderTest, ctx.getMethodUnderTest()); + assertFalse(ctx.isNewTestClassCreated()); + } + + @Test + public void three_arg_constructor_should_store_new_test_class_flag() + { + IMethod testMethod = mock(IMethod.class); + IMethod methodUnderTest = mock(IMethod.class); + ICompilationUnit testCu = mock(ICompilationUnit.class); + ICompilationUnit cutCu = mock(ICompilationUnit.class); + when(testMethod.getCompilationUnit()).thenReturn(testCu); + when(methodUnderTest.getCompilationUnit()).thenReturn(cutCu); + + assertTrue(new AddTestMethodContext(testMethod, methodUnderTest, true).isNewTestClassCreated()); + assertFalse(new AddTestMethodContext(testMethod, methodUnderTest, false).isNewTestClassCreated()); + } + + @Test + public void should_set_and_get_preferences() + { + IMethod testMethod = mock(IMethod.class); + IMethod methodUnderTest = mock(IMethod.class); + ICompilationUnit testCu = mock(ICompilationUnit.class); + ICompilationUnit cutCu = mock(ICompilationUnit.class); + when(testMethod.getCompilationUnit()).thenReturn(testCu); + when(methodUnderTest.getCompilationUnit()).thenReturn(cutCu); + + AddTestMethodContext ctx = new AddTestMethodContext(testMethod, methodUnderTest); + assertNull(ctx.getPreferences()); + + var prefs = mock(org.moreunit.preferences.Preferences.class); + ctx.setPreferences(prefs); + assertEquals(prefs, ctx.getPreferences()); + } +} From f72aac406dc973b4af5ff537d38d0369b0014500 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 22:00:09 +0200 Subject: [PATCH 07/10] test: add DependenciesTreeMemberComparator and DependencyInjectionPointStore tests --- .../DependencyInjectionPointStoreTest.java | 51 +++++++++++++++ .../DependenciesTreeMemberComparatorTest.java | 65 +++++++++++++++++++ 2 files changed, 116 insertions(+) create mode 100644 org.moreunit.mock.test/test/org/moreunit/mock/dependencies/DependencyInjectionPointStoreTest.java create mode 100644 org.moreunit.mock.test/test/org/moreunit/mock/wizard/DependenciesTreeMemberComparatorTest.java diff --git a/org.moreunit.mock.test/test/org/moreunit/mock/dependencies/DependencyInjectionPointStoreTest.java b/org.moreunit.mock.test/test/org/moreunit/mock/dependencies/DependencyInjectionPointStoreTest.java new file mode 100644 index 00000000..164818f1 --- /dev/null +++ b/org.moreunit.mock.test/test/org/moreunit/mock/dependencies/DependencyInjectionPointStoreTest.java @@ -0,0 +1,51 @@ +package org.moreunit.mock.dependencies; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.List; + +import org.eclipse.jdt.core.IField; +import org.eclipse.jdt.core.IMethod; +import org.eclipse.jdt.core.JavaModelException; +import org.junit.jupiter.api.Test; +import org.moreunit.core.log.Logger; + +public class DependencyInjectionPointStoreTest +{ + @Test + public void should_store_constructors_setters_and_fields() throws JavaModelException + { + DependencyInjectionPointStore store = new DependencyInjectionPointStore(mock(Logger.class)); + + IMethod constructor = mock(IMethod.class); + when(constructor.isConstructor()).thenReturn(true); + + IMethod setter = mock(IMethod.class); + when(setter.isConstructor()).thenReturn(false); + + IField field = mock(IField.class); + + store.setInjectionPoints(List.of(constructor, setter, field)); + + assertEquals(1, store.getConstructors().size()); + assertEquals(1, store.getSetters().size()); + assertEquals(1, store.getFields().size()); + } + + @Test + public void should_clear_before_inserting_new_members() throws JavaModelException + { + DependencyInjectionPointStore store = new DependencyInjectionPointStore(mock(Logger.class)); + + IMethod constructor = mock(IMethod.class); + when(constructor.isConstructor()).thenReturn(true); + store.setInjectionPoints(List.of(constructor)); + assertTrue(store.getConstructors().size() > 0); + + store.setInjectionPoints(List.of()); + assertTrue(store.getConstructors().isEmpty()); + } +} diff --git a/org.moreunit.mock.test/test/org/moreunit/mock/wizard/DependenciesTreeMemberComparatorTest.java b/org.moreunit.mock.test/test/org/moreunit/mock/wizard/DependenciesTreeMemberComparatorTest.java new file mode 100644 index 00000000..3689ffce --- /dev/null +++ b/org.moreunit.mock.test/test/org/moreunit/mock/wizard/DependenciesTreeMemberComparatorTest.java @@ -0,0 +1,65 @@ +package org.moreunit.mock.wizard; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.eclipse.jdt.core.IField; +import org.eclipse.jdt.core.IMember; +import org.eclipse.jdt.core.IMethod; +import org.eclipse.jdt.core.JavaModelException; +import org.junit.jupiter.api.Test; + +public class DependenciesTreeMemberComparatorTest +{ + private final DependenciesTreeMemberComparator comparator = new DependenciesTreeMemberComparator(); + + @Test + public void methods_should_come_before_fields() + { + IMethod method = mock(IMethod.class); + IField field = mock(IField.class); + + assertTrue(comparator.compare(method, field) < 0); + assertTrue(comparator.compare(field, method) > 0); + } + + @Test + public void constructors_should_come_before_setters() throws JavaModelException + { + IMethod constructor = mock(IMethod.class); + IMethod setter = mock(IMethod.class); + when(constructor.isConstructor()).thenReturn(true); + when(setter.isConstructor()).thenReturn(false); + + assertTrue(comparator.compare(constructor, setter) < 0); + assertTrue(comparator.compare(setter, constructor) > 0); + } + + @Test + public void constructors_with_more_params_should_come_first() throws JavaModelException + { + IMethod manyParams = mock(IMethod.class); + IMethod fewParams = mock(IMethod.class); + when(manyParams.isConstructor()).thenReturn(true); + when(fewParams.isConstructor()).thenReturn(true); + when(manyParams.getNumberOfParameters()).thenReturn(3); + when(fewParams.getNumberOfParameters()).thenReturn(1); + + assertTrue(comparator.compare(manyParams, fewParams) < 0); + assertTrue(comparator.compare(fewParams, manyParams) > 0); + } + + @Test + public void same_type_members_should_be_ordered_by_name() + { + IField a = mock(IField.class); + IField b = mock(IField.class); + when(a.getElementName()).thenReturn("apple"); + when(b.getElementName()).thenReturn("banana"); + + assertTrue(comparator.compare(a, b) < 0); + assertTrue(comparator.compare(b, a) > 0); + } +} From 13ec1386312452e8f4322b79198f0a1d9ec47031 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 22:03:38 +0200 Subject: [PATCH 08/10] test: add ContextFactory tests --- .../mock/templates/ContextFactoryTest.java | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 org.moreunit.mock.test/test/org/moreunit/mock/templates/ContextFactoryTest.java diff --git a/org.moreunit.mock.test/test/org/moreunit/mock/templates/ContextFactoryTest.java b/org.moreunit.mock.test/test/org/moreunit/mock/templates/ContextFactoryTest.java new file mode 100644 index 00000000..0276cca1 --- /dev/null +++ b/org.moreunit.mock.test/test/org/moreunit/mock/templates/ContextFactoryTest.java @@ -0,0 +1,33 @@ +package org.moreunit.mock.templates; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IType; +import org.junit.jupiter.api.Test; +import org.moreunit.mock.dependencies.Dependencies; + +public class ContextFactoryTest +{ + @Test + public void should_create_mocking_context() throws MockingTemplateException + { + ContextFactory factory = new ContextFactory(); + MockingContext ctx = factory.createMockingContext( + mock(Dependencies.class), mock(IType.class), "JUNIT5", mock(ICompilationUnit.class)); + + assertNotNull(ctx); + } + + @Test + public void should_create_eclipse_template_context() throws MockingTemplateException + { + ContextFactory factory = new ContextFactory(); + MockingContext ctx = new MockingContext( + mock(Dependencies.class), mock(IType.class), mock(ICompilationUnit.class), "JUNIT5", + java.util.Collections.emptyList()); + + assertNotNull(factory.createEclipseTemplateContext(ctx)); + } +} From 8c1e11a4913e6e5a82eb34bd36c1e3a5e04e1ffe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 22:04:55 +0200 Subject: [PATCH 09/10] test: add LogHandler and TypeFacadeFactory tests --- .../mock/elements/TypeFacadeFactoryTest.java | 25 +++++++++++++++++++ .../test/org/moreunit/log/LogHandlerTest.java | 14 +++++++++++ 2 files changed, 39 insertions(+) create mode 100644 org.moreunit.mock.test/test/org/moreunit/mock/elements/TypeFacadeFactoryTest.java create mode 100644 org.moreunit.test/test/org/moreunit/log/LogHandlerTest.java diff --git a/org.moreunit.mock.test/test/org/moreunit/mock/elements/TypeFacadeFactoryTest.java b/org.moreunit.mock.test/test/org/moreunit/mock/elements/TypeFacadeFactoryTest.java new file mode 100644 index 00000000..322b692b --- /dev/null +++ b/org.moreunit.mock.test/test/org/moreunit/mock/elements/TypeFacadeFactoryTest.java @@ -0,0 +1,25 @@ +package org.moreunit.mock.elements; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.junit.jupiter.api.Test; + +public class TypeFacadeFactoryTest +{ + @Test + public void should_create_and_check() + { + TypeFacadeFactory factory = new TypeFacadeFactory(); + assertFalse(factory.isTestCase(mock(ICompilationUnit.class))); + } + + @Test + public void should_create_facade() + { + TypeFacadeFactory factory = new TypeFacadeFactory(); + assertNotNull(factory.createFacade(mock(ICompilationUnit.class))); + } +} diff --git a/org.moreunit.test/test/org/moreunit/log/LogHandlerTest.java b/org.moreunit.test/test/org/moreunit/log/LogHandlerTest.java new file mode 100644 index 00000000..4f341240 --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/log/LogHandlerTest.java @@ -0,0 +1,14 @@ +package org.moreunit.log; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.Test; + +public class LogHandlerTest +{ + @Test + public void should_get_instance() + { + assertNotNull(LogHandler.getInstance()); + } +} From e980325a8f9829d53834606f596dc111d531ff01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9lios=20GILLES?= Date: Fri, 3 Jul 2026 22:06:38 +0200 Subject: [PATCH 10/10] test: add CutImportChange tests --- .../refactoring/CutImportChangeTest.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 org.moreunit.test/test/org/moreunit/refactoring/CutImportChangeTest.java diff --git a/org.moreunit.test/test/org/moreunit/refactoring/CutImportChangeTest.java b/org.moreunit.test/test/org/moreunit/refactoring/CutImportChangeTest.java new file mode 100644 index 00000000..cb366078 --- /dev/null +++ b/org.moreunit.test/test/org/moreunit/refactoring/CutImportChangeTest.java @@ -0,0 +1,27 @@ +package org.moreunit.refactoring; + +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.junit.jupiter.api.Test; + +public class CutImportChangeTest +{ + @Test + public void should_store_import_in_name() + { + ICompilationUnit cu = mock(ICompilationUnit.class); + CutImportChange change = new CutImportChange("java.util.List", cu); + + assertTrue(change.getName().contains("java.util.List")); + } + + @Test + public void should_initialize_validation_data() + { + CutImportChange change = new CutImportChange("java.util.List", mock(ICompilationUnit.class)); + // should not throw despite null pm + change.initializeValidationData(null); + } +}