test: improve coverage for core utility classes

org.moreunit.core.test/src/org/moreunit/core/util/ExtendedSafeRunnerTest.java

@@ -0,0 +1,70 @@
+package org.moreunit.core.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class ExtendedSafeRunnerTest {
+
+    @Test
+    void testApplyToSingle() {
+        ExtendedSafeRunner runner = new ExtendedSafeRunner();
+        String result = runner.applyTo("input", new ExtendedSafeRunner.GenericRunnable<String, String>() {
+            @Override
+            public void handleException(Throwable throwable, String element) {
+            }
+
+            @Override
+            public String run(String element) throws Exception {
+                return element + "-processed";
+            }
+        });
+
+        assertThat(result).isEqualTo("input-processed");
+    }
+
+    @Test
+    void testApplyToIterable() {
+        ExtendedSafeRunner runner = new ExtendedSafeRunner();
+        List<String> inputs = Arrays.asList("a", "b", "c");
+
+        Iterable<String> results = runner.applyTo(inputs, new ExtendedSafeRunner.GenericRunnable<String, String>() {
+            @Override
+            public void handleException(Throwable throwable, String element) {
+            }
+
+            @Override
+            public String run(String element) throws Exception {
+                return element.toUpperCase();
+            }
+        });
+
+        assertThat(results).containsExactly("A", "B", "C");
+    }
+
+    @Test
+    void testApplyToExceptionHandled() {
+        ExtendedSafeRunner runner = new ExtendedSafeRunner();
+
+        final boolean[] handled = new boolean[1];
+
+        String result = runner.applyTo("error", new ExtendedSafeRunner.GenericRunnable<String, String>() {
+            @Override
+            public void handleException(Throwable throwable, String element) {
+                handled[0] = true;
+                assertThat(element).isEqualTo("error");
+            }
+
+            @Override
+            public String run(String element) throws Exception {
+                throw new RuntimeException("test exception");
+            }
+        });
+
+        assertThat(result).isNull(); // run failed, result not set
+        assertThat(handled[0]).isTrue();
+    }
+}

org.moreunit.core.test/src/org/moreunit/core/util/FeaturesTest.java

@@ -0,0 +1,39 @@
+package org.moreunit.core.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+class FeaturesTest {
+
+    private static final String TEST_FEATURE = "org.moreunit.testFeature";
+
+    @AfterEach
+    void tearDown() {
+        System.clearProperty(TEST_FEATURE);
+    }
+
+    @Test
+    void testIsActiveDefault() {
+        assertThat(Features.isActive("non.existing.feature")).isFalse();
+    }
+
+    @Test
+    void testIsActiveTrue() {
+        System.setProperty(TEST_FEATURE, "true");
+        assertThat(Features.isActive(TEST_FEATURE)).isTrue();
+    }
+
+    @Test
+    void testIsActiveFalse() {
+        System.setProperty(TEST_FEATURE, "false");
+        assertThat(Features.isActive(TEST_FEATURE)).isFalse();
+    }
+
+    @Test
+    void testIsActiveInvalid() {
+        System.setProperty(TEST_FEATURE, "invalid");
+        assertThat(Features.isActive(TEST_FEATURE)).isFalse();
+    }
+}

org.moreunit.core.test/src/org/moreunit/core/util/LRUCacheTest.java

@@ -0,0 +1,43 @@
+package org.moreunit.core.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class LRUCacheTest {
+
+    @Test
+    void testEvictsEldestEntry() {
+        LRUCache<String, String> cache = new LRUCache<>(2);
+
+        cache.put("1", "one");
+        cache.put("2", "two");
+        cache.put("3", "three");
+
+        assertThat(cache.size()).isEqualTo(2);
+        assertThat(cache.containsKey("1")).isFalse();
+        assertThat(cache.containsKey("2")).isTrue();
+        assertThat(cache.containsKey("3")).isTrue();
+    }
+
+    @Test
+    void testAccessOrder() {
+        LRUCache<String, String> cache = new LRUCache<>(3);
+
+        cache.put("1", "one");
+        cache.put("2", "two");
+        cache.put("3", "three");
+
+        // Access "1" to make it the most recently used
+        cache.get("1");
+
+        // Put "4", should evict "2" which is now the least recently used
+        cache.put("4", "four");
+
+        assertThat(cache.size()).isEqualTo(3);
+        assertThat(cache.containsKey("2")).isFalse();
+        assertThat(cache.containsKey("1")).isTrue();
+        assertThat(cache.containsKey("3")).isTrue();
+        assertThat(cache.containsKey("4")).isTrue();
+    }
+}

org.moreunit.core.test/src/org/moreunit/core/util/ObjectsTest.java

@@ -0,0 +1,25 @@
+package org.moreunit.core.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class ObjectsTest {
+
+    @Test
+    void testEqual() {
+        assertThat(Objects.equal(null, null)).isTrue();
+        assertThat(Objects.equal("a", "a")).isTrue();
+        assertThat(Objects.equal(new String("a"), new String("a"))).isTrue();
+
+        assertThat(Objects.equal("a", null)).isFalse();
+        assertThat(Objects.equal(null, "a")).isFalse();
+        assertThat(Objects.equal("a", "b")).isFalse();
+    }
+
+    @Test
+    void testHash() {
+        assertThat(Objects.hash("a", "b")).isEqualTo(java.util.Arrays.hashCode(new Object[]{"a", "b"}));
+        assertThat(Objects.hash(null, "b")).isEqualTo(java.util.Arrays.hashCode(new Object[]{null, "b"}));
+    }
+}

org.moreunit.core.test/src/org/moreunit/core/util/StringLengthComparatorTest.java

@@ -0,0 +1,29 @@
+package org.moreunit.core.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class StringLengthComparatorTest {
+
+    @Test
+    void testCompare() {
+        StringLengthComparator comparator = new StringLengthComparator();
+
+        assertThat(comparator.compare("a", "bb")).isNegative();
+        assertThat(comparator.compare("aaa", "bb")).isPositive();
+        assertThat(comparator.compare("aa", "bb")).isZero();
+    }
+
+    @Test
+    void testSort() {
+        List<String> list = Arrays.asList("apple", "pie", "banana", "kiwi");
+        Collections.sort(list, new StringLengthComparator());
+
+        assertThat(list).containsExactly("pie", "kiwi", "apple", "banana");
+    }
+}

org.moreunit.swtbot.test/pom.xml

@@ -22,8 +22,8 @@
             <groupId>org.eclipse.tycho</groupId>
             <artifactId>tycho-surefire-plugin</artifactId>
             <configuration>
-              <useUIHarness>true</useUIHarness>
-              <useUIThread>false</useUIThread>
+              <useUIHarness>${tests.use.ui}</useUIHarness>
+              <useUIThread>${tests.use.ui}</useUIThread>
               <product>org.eclipse.platform.ide</product>
               <application>org.eclipse.ui.ide.workbench</application>
             </configuration>