More tests for comparators.

src/evoal/core/de.evoal.core.main/pom.xml

@@ -280,6 +280,13 @@
 			<version>3.1.0.Final</version>
 			<scope>test</scope>
 		</dependency>
+
+		<dependency>
+			<groupId>org.mockito</groupId>
+			<artifactId>mockito-junit-jupiter</artifactId>
+			<version>5.3.1</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 
 	<build>

src/evoal/core/de.evoal.core.main/src/main/java/de/evoal/core/main/comparator/NumericOptimisationValue.java

@@ -24,7 +24,7 @@ public class NumericOptimisationValue extends Number implements OptimisationValu
     }
 
     @Override
-    public int compareTo(final OptimisationValue other) {
+    public int compareTo(final @NonNull OptimisationValue other) {
         if(!(other instanceof NumericOptimisationValue)) {
             throw new IllegalArgumentException("Only allowed to compare NumericOptimisationValue");
         }

src/evoal/core/de.evoal.core.main/src/main/java/de/evoal/core/main/comparator/WeightedSumComparator.java

@@ -18,12 +18,12 @@ public class WeightedSumComparator implements OptimisationValueComparator {
     private ExpressionEvaluator evaluator;
 
     @Override
-    public OptimisationValue toValue(final double[] fitnessValues) {
+    public WeightedSumOptimisationValue toValue(final double[] fitnessValues) {
         return WeightedSumOptimisationValue.of(weights, fitnessValues);
     }
 
     @Override
-    public OptimisationValueComparator init(final Instance config) {
+    public WeightedSumComparator init(final Instance config) {
         weights = evaluator.attributeToDoubleArray(config, "weights");
 
         return this;

src/evoal/core/de.evoal.core.main/src/main/java/de/evoal/core/main/comparator/WeightedSumOptimisationValue.java

@@ -30,7 +30,7 @@ public class WeightedSumOptimisationValue implements OptimisationValue {
     }
 
     @Override
-    public int compareTo(final OptimisationValue other) {
+    public int compareTo(final @NonNull OptimisationValue other) {
         if(!(other instanceof WeightedSumOptimisationValue)) {
             throw new IllegalArgumentException("Only allowed to compare WeightedSumFitnessValue");
         }
@@ -48,7 +48,7 @@ public class WeightedSumOptimisationValue implements OptimisationValue {
 
     @Override
     public String toString() {
-    	return "WeightedSum [fit=" + Arrays.toString(fitnessValues) + ", w" + Arrays.toString(normalizedWeights) + "]";
+    	return "WeightedSum [fit=" + Arrays.toString(fitnessValues) + ", w=" + Arrays.toString(normalizedWeights) + "]";
     }
 
     @Override

src/evoal/core/de.evoal.core.main/src/test/java/de/evoal/core/main/comparator/NumericOptimisationValueTest.java

@@ -21,6 +21,21 @@ public class NumericOptimisationValueTest {
         Assertions.assertEquals(42.0, optValue.doubleValue());
     }
 
+    @Test
+    public void testCompareToNull() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        Assertions.assertThrows(NullPointerException.class, () -> testee.compareTo(null));
+    }
+
+    @Test
+    public void testCompareToSelf() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        int result = testee.compareTo(testee);
+        Assertions.assertEquals(0, result);
+    }
+
     @Test
     public void testCompareToOptimisationValueSameContent() {
         double [] fitness = {42.0};

src/evoal/core/de.evoal.core.main/src/test/java/de/evoal/core/main/comparator/WeightedSumComparatorTest.java

+package de.evoal.core.main.comparator;
+
+import de.evoal.core.api.languages.ExpressionEvaluator;
+import de.evoal.languages.model.base.Instance;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+public class WeightedSumComparatorTest {
+
+    @Mock
+    private ExpressionEvaluator evaluator;
+
+    @Mock
+    private Instance configuration;
+
+    @InjectMocks
+    private WeightedSumComparator testee;
+
+    @Test
+    public void testInitReturnSelf() {
+        Mockito.when(evaluator.attributeToDoubleArray(Mockito.same(configuration), Mockito.eq("weights")))
+               .thenReturn(new double[] {1.0});
+
+        Assertions.assertNotNull(testee);
+        Assertions.assertTrue(() -> testee == testee.init(configuration), "Init is exepected to return self.");
+    }
+
+    @Test
+    public void testToValue() {
+        Mockito.when(evaluator.attributeToDoubleArray(Mockito.same(configuration), Mockito.eq("weights")))
+                .thenReturn(new double[] {2.0});
+
+        double [] fitness = {42.0};
+
+        testee.init(configuration);
+        final WeightedSumOptimisationValue value = testee.toValue(fitness);
+
+        Assertions.assertNotNull(value);
+    }
+
+
+}

src/evoal/core/de.evoal.core.main/src/test/java/de/evoal/core/main/comparator/WeightedSumOptimisationValueTest.java

+package de.evoal.core.main.comparator;
+
+import de.evoal.core.api.optimisation.OptimisationValue;
+import de.evoal.core.api.utils.Requirements;
+import de.evoal.core.main.comparator.WeightedSumOptimisationValue;
+import lombok.Getter;
+import lombok.NonNull;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+public class WeightedSumOptimisationValueTest  {
+    @Test
+    public void testGetFitnessValues() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0}, new double [] {42.0});
+
+        Assertions.assertNotNull(testee);
+        double [] values = testee.getFitnessValues();
+
+        Assertions.assertNotNull(values);
+        Assertions.assertEquals(1, values.length);
+        Assertions.assertEquals(42.0, values[0]);
+    }
+
+    @Test
+    public void testCompareToNull() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        Assertions.assertThrows(NullPointerException.class, () -> testee.compareTo(null));
+    }
+
+    @Test
+    public void testCompareToSelf() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        int result = testee.compareTo(testee);
+        Assertions.assertEquals(0, result);
+    }
+
+    @Test
+    public void testCompareToIdentical() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+        WeightedSumOptimisationValue other = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        int result = testee.compareTo(other);
+        Assertions.assertEquals(0, result);
+    }
+
+    @Test
+    public void testCompareToLarger() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+        WeightedSumOptimisationValue other = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 14.0});
+
+        int result = testee.compareTo(other);
+        Assertions.assertEquals(-1, result);
+    }
+
+    @Test
+    public void testCompareToSmaller() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+        WeightedSumOptimisationValue other = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {9.0, 12.0});
+
+        int result = testee.compareTo(other);
+        Assertions.assertEquals(1, result);
+    }
+
+    @Test
+    public void testCompareToOtherInstance() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+        NumericOptimisationValue other = NumericOptimisationValue.of(new double [] {9.0});
+
+        Assertions.assertThrows(IllegalArgumentException.class, () -> testee.compareTo(other));
+    }
+
+    @Test
+    public void testToStringWithOneDimension() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0}, new double [] {42.0});
+
+        Assertions.assertNotNull(testee);
+        Assertions.assertEquals("WeightedSum [fit=[42.0], w=[1.0]]", testee.toString());
+    }
+
+    @Test
+    public void testToStringWithTwoDimensions() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        Assertions.assertNotNull(testee);
+
+        Assertions.assertEquals("WeightedSum [fit=[42.0, 12.0], w=[0.4, 0.6]]", testee.toString());
+    }
+
+    @Test
+    public void testToStatistics() {
+        WeightedSumOptimisationValue testee = WeightedSumOptimisationValue.of(new double [] {2.0, 3.0}, new double [] {42.0, 12.0});
+
+        Assertions.assertNotNull(testee);
+        Object [] result = testee.toStatistics();
+
+        Assertions.assertNotNull(result);
+        Assertions.assertEquals(2, result.length);
+        Assertions.assertEquals(42.0, result[0]);
+        Assertions.assertEquals(12.0, result[1]);
+    }
+}