From 75e58d2a0da6d3425fe35eb43953ec4dab68bc68 Mon Sep 17 00:00:00 2001 From: Fedor Smirnov Date: Sat, 10 Feb 2018 10:43:18 +0100 Subject: [PATCH 1/4] tests for SelectGenotype --- .../core/genotype/SelectGenotypeTest.java | 115 ++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 opt4j-core/src/test/java/org/opt4j/core/genotype/SelectGenotypeTest.java diff --git a/opt4j-core/src/test/java/org/opt4j/core/genotype/SelectGenotypeTest.java b/opt4j-core/src/test/java/org/opt4j/core/genotype/SelectGenotypeTest.java new file mode 100644 index 00000000..b59a082b --- /dev/null +++ b/opt4j-core/src/test/java/org/opt4j/core/genotype/SelectGenotypeTest.java @@ -0,0 +1,115 @@ +package org.opt4j.core.genotype; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Random; +import java.util.Set; + +import org.junit.Test; + +public class SelectGenotypeTest { + + class MockObject { + private final double field1; + private final int field2; + + public MockObject(double field1, int field2) { + this.field1 = field1; + this.field2 = field2; + } + + public double getField1() { + return field1; + } + + public int getField2() { + return field2; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + getOuterType().hashCode(); + long temp; + temp = Double.doubleToLongBits(field1); + result = prime * result + (int) (temp ^ (temp >>> 32)); + result = prime * result + field2; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + MockObject other = (MockObject) obj; + if (!getOuterType().equals(other.getOuterType())) + return false; + if (Double.doubleToLongBits(field1) != Double.doubleToLongBits(other.field1)) + return false; + if (field2 != other.field2) + return false; + return true; + } + + private SelectGenotypeTest getOuterType() { + return SelectGenotypeTest.this; + } + } + + public void testGenotype(SelectGenotype selectGenotype, Set mockObjects) { + Random rand = new Random(); + assertTrue(selectGenotype.isEmpty()); + selectGenotype.init(rand, 5); + assertEquals(5, selectGenotype.size()); + for (int i = 0; i < 5; i++) { + assertEquals(0, selectGenotype.getLowerBound(i)); + assertEquals(3, selectGenotype.getUpperBound(i)); + assertTrue(mockObjects.contains(selectGenotype.getValue(i))); + } + + SelectGenotype other = selectGenotype.newInstance(); + assertNotEquals(selectGenotype, other); + assertTrue(other.isEmpty()); + } + + @Test + public void testArrayConstructor() { + MockObject obj1 = new MockObject(1.0, 1); + MockObject obj2 = new MockObject(2.0, 2); + MockObject obj3 = new MockObject(3.0, 3); + MockObject[] inputArray = { obj1, obj2, obj3, obj1 }; + Set mockObjects = new HashSet(); + mockObjects.add(obj1); + mockObjects.add(obj2); + mockObjects.add(obj3); + SelectGenotype selectGenotype = new SelectGenotype(inputArray); + testGenotype(selectGenotype, mockObjects); + } + + @Test + public void testListConstructor() { + List inputList = new ArrayList(); + Set mockObjects = new HashSet(); + MockObject obj1 = new MockObject(1.0, 1); + MockObject obj2 = new MockObject(2.0, 2); + MockObject obj3 = new MockObject(3.0, 3); + inputList.add(obj1); + inputList.add(obj2); + inputList.add(obj3); + inputList.add(obj1); + mockObjects.add(obj1); + mockObjects.add(obj2); + mockObjects.add(obj3); + SelectGenotype selectGenotype = new SelectGenotype(inputList); + testGenotype(selectGenotype, mockObjects); + } + +} From a80850a8780729e64be83281d99a253339965f84 Mon Sep 17 00:00:00 2001 From: Fedor Smirnov Date: Sat, 10 Feb 2018 18:08:14 +0100 Subject: [PATCH 2/4] added tests for the PermutationGenotype --- .../genotype/PermutationGenotypeTest.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 opt4j-core/src/test/java/org/opt4j/core/genotype/PermutationGenotypeTest.java diff --git a/opt4j-core/src/test/java/org/opt4j/core/genotype/PermutationGenotypeTest.java b/opt4j-core/src/test/java/org/opt4j/core/genotype/PermutationGenotypeTest.java new file mode 100644 index 00000000..bf7a2cfd --- /dev/null +++ b/opt4j-core/src/test/java/org/opt4j/core/genotype/PermutationGenotypeTest.java @@ -0,0 +1,54 @@ +package org.opt4j.core.genotype; + +import static org.junit.Assert.*; + +import java.util.HashSet; +import java.util.Random; +import java.util.Set; + +import org.junit.Test; + +public class PermutationGenotypeTest { + + @Test + public void testEmptyConstructor() { + Random rand = new Random(); + PermutationGenotype permutationGenotype = new PermutationGenotype(); + permutationGenotype.add(1); + permutationGenotype.add(2); + permutationGenotype.add(3); + + assertEquals(3, permutationGenotype.size()); + permutationGenotype.init(rand); + assertEquals(3, permutationGenotype.size()); + assertTrue(permutationGenotype.contains(1)); + assertTrue(permutationGenotype.contains(2)); + assertTrue(permutationGenotype.contains(3)); + + PermutationGenotype other = permutationGenotype.newInstance(); + assertNotEquals(permutationGenotype, other); + assertTrue(other.isEmpty()); + } + + @Test + public void testCollectionConstructor() { + Random rand = new Random(); + Set inputCollection = new HashSet(); + inputCollection.add(1); + inputCollection.add(2); + inputCollection.add(3); + PermutationGenotype permutationGenotype = new PermutationGenotype(inputCollection); + + assertEquals(3, permutationGenotype.size()); + permutationGenotype.init(rand); + assertEquals(3, permutationGenotype.size()); + assertTrue(permutationGenotype.contains(1)); + assertTrue(permutationGenotype.contains(2)); + assertTrue(permutationGenotype.contains(3)); + + PermutationGenotype other = permutationGenotype.newInstance(); + assertNotEquals(permutationGenotype, other); + assertTrue(other.isEmpty()); + } + +} From d13ef86c85fb357011875cbe691b2a0a8d6f2461 Mon Sep 17 00:00:00 2001 From: Fedor Smirnov Date: Sat, 10 Feb 2018 18:08:44 +0100 Subject: [PATCH 3/4] tests and changes for the IntegerMapGenotype --- .../core/genotype/IntegerMapGenotype.java | 31 +- .../core/genotype/IntegerMapGenotypeTest.java | 264 ++++++++++++++++++ 2 files changed, 290 insertions(+), 5 deletions(-) create mode 100644 opt4j-core/src/test/java/org/opt4j/core/genotype/IntegerMapGenotypeTest.java diff --git a/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java b/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java index 76aec291..637c4f42 100644 --- a/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java +++ b/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java @@ -19,14 +19,16 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. *******************************************************************************/ - + package org.opt4j.core.genotype; import java.lang.reflect.Constructor; import java.util.Collection; import java.util.Collections; +import java.util.HashSet; import java.util.List; import java.util.Random; +import java.util.Set; import org.opt4j.core.Genotype; @@ -68,6 +70,13 @@ public class IntegerMapGenotype extends IntegerGenotype implements MapGenotyp */ public IntegerMapGenotype(List list, Bounds bounds) { super(bounds); + Set uniqueKeys = new HashSet(); + for (K k : list) { + uniqueKeys.add(k); + } + if (uniqueKeys.size() < list.size()) { + throw new IllegalArgumentException("The provided key objects have to be unique"); + } this.list = list; } @@ -136,9 +145,16 @@ public Integer getValue(K key) { */ @Override public void setValue(K key, Integer value) { + if (!list.contains(key)) { + throw new IllegalArgumentException("Invalid key"); + } int i = list.indexOf(key); while (size() <= i) { - add(bounds.getLowerBound(i)); + add(bounds.getLowerBound(size())); + } + if (bounds.getLowerBound(i) > value || bounds.getUpperBound(i) < value) { + throw new IllegalArgumentException( + "The provided value does not lie within the bounds for the provided key"); } set(i, value); } @@ -166,13 +182,15 @@ public G newInstance() { */ @Override public String toString() { - String s = "["; + StringBuilder stringBuilder = new StringBuilder(); + stringBuilder.append("["); for (int i = 0; i < size(); i++) { K key = list.get(i); double value = this.get(i); - s += key + "=" + value + ";"; + stringBuilder.append(key + "=" + value + ";"); } - return s + "]"; + stringBuilder.append("]"); + return stringBuilder.toString(); } /* @@ -182,6 +200,9 @@ public String toString() { */ @Override public int getIndexOf(K key) { + if (!list.contains(key)) { + throw new IllegalArgumentException("Invalid key"); + } return list.indexOf(key); } diff --git a/opt4j-core/src/test/java/org/opt4j/core/genotype/IntegerMapGenotypeTest.java b/opt4j-core/src/test/java/org/opt4j/core/genotype/IntegerMapGenotypeTest.java new file mode 100644 index 00000000..25e36740 --- /dev/null +++ b/opt4j-core/src/test/java/org/opt4j/core/genotype/IntegerMapGenotypeTest.java @@ -0,0 +1,264 @@ +package org.opt4j.core.genotype; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Random; + +import org.junit.Test; + +public class IntegerMapGenotypeTest { + + class MockObject { + private final double field1; + private final int field2; + + public MockObject(double field1, int field2) { + this.field1 = field1; + this.field2 = field2; + } + + public double getField1() { + return field1; + } + + public int getField2() { + return field2; + } + + @Override + public String toString() { + return "mock"; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + getOuterType().hashCode(); + long temp; + temp = Double.doubleToLongBits(field1); + result = prime * result + (int) (temp ^ (temp >>> 32)); + result = prime * result + field2; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + MockObject other = (MockObject) obj; + if (!getOuterType().equals(other.getOuterType())) + return false; + if (Double.doubleToLongBits(field1) != Double.doubleToLongBits(other.field1)) + return false; + if (field2 != other.field2) + return false; + return true; + } + + private IntegerMapGenotypeTest getOuterType() { + return IntegerMapGenotypeTest.this; + } + } + + @Test(expected = UnsupportedOperationException.class) + public void testForbiddenInit() { + Random rand = new Random(); + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + integerMapGenotype.init(rand, 3); + } + + @Test(expected = IllegalArgumentException.class) + public void testNonUniqueKeys() { + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + inputList.add(mockup1); + new IntegerMapGenotype(inputList, bounds); + } + + @Test(expected = IllegalArgumentException.class) + public void testGetIndexInvalidKey() { + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + MockObject mockup4 = new MockObject(4.0, 4); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + integerMapGenotype.getIndexOf(mockup4); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetInvalidKey() { + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + MockObject mockup4 = new MockObject(4.0, 4); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + integerMapGenotype.setValue(mockup4, 1); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetOutOfLowerBoundsValue() { + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + integerMapGenotype.setValue(mockup3, -1); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetOutOfUpperBoundsValue() { + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + integerMapGenotype.setValue(mockup3, 5); + } + + @Test + public void testToString() { + Random rand = new Random(); + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 1, 2, 3 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + integerMapGenotype.init(rand); + assertEquals("[mock=1.0;mock=2.0;mock=3.0;]", integerMapGenotype.toString()); + } + + @Test + public void testFixedBoundConstructor() { + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, 1, 3); + for (int i = 1; i < 4; i++) { + assertEquals(1, integerMapGenotype.getLowerBound(i)); + assertEquals(3, integerMapGenotype.getUpperBound(i)); + } + } + + @Test + public void testBoundConstructor() { + Random rand = new Random(); + int[] lowerBounds = { 1, 2, 3 }; + int[] upperBounds = { 2, 3, 4 }; + Bounds bounds = new IntegerBounds(lowerBounds, upperBounds); + MockObject mockup1 = new MockObject(1.0, 1); + MockObject mockup2 = new MockObject(2.0, 2); + MockObject mockup3 = new MockObject(3.0, 3); + MockObject mockup4 = new MockObject(4.0, 4); + List inputList = new ArrayList(); + inputList.add(mockup1); + inputList.add(mockup2); + inputList.add(mockup3); + IntegerMapGenotype integerMapGenotype = new IntegerMapGenotype( + inputList, bounds); + assertTrue(integerMapGenotype.isEmpty()); + assertEquals(integerMapGenotype.getLowerBound(0), 1); + assertEquals(integerMapGenotype.getLowerBound(1), 2); + assertEquals(integerMapGenotype.getLowerBound(2), 3); + assertEquals(integerMapGenotype.getUpperBound(0), 2); + assertEquals(integerMapGenotype.getUpperBound(1), 3); + assertEquals(integerMapGenotype.getUpperBound(2), 4); + integerMapGenotype.init(rand); + assertEquals(3, integerMapGenotype.size()); + assertTrue(integerMapGenotype.containsKey(mockup1)); + assertTrue(integerMapGenotype.containsKey(mockup2)); + assertTrue(integerMapGenotype.containsKey(mockup3)); + assertFalse(integerMapGenotype.containsKey(mockup4)); + assertEquals(0, integerMapGenotype.getIndexOf(mockup1)); + assertEquals(1, integerMapGenotype.getIndexOf(mockup2)); + assertEquals(2, integerMapGenotype.getIndexOf(mockup3)); + Collection keys = integerMapGenotype.getKeys(); + assertTrue(keys.contains(mockup1)); + assertTrue(keys.contains(mockup2)); + assertTrue(keys.contains(mockup3)); + assertFalse(keys.contains(mockup4)); + assertTrue(integerMapGenotype.getValue(mockup1) >= 1); + assertTrue(integerMapGenotype.getValue(mockup1) <= 2); + assertTrue(integerMapGenotype.getValue(mockup2) >= 2); + assertTrue(integerMapGenotype.getValue(mockup2) <= 3); + assertTrue(integerMapGenotype.getValue(mockup3) >= 3); + assertTrue(integerMapGenotype.getValue(mockup3) <= 4); + integerMapGenotype.setValue(mockup3, 4); + assertEquals(new Long(4), new Long(integerMapGenotype.getValue(mockup3))); + IntegerMapGenotype other = integerMapGenotype.newInstance(); + assertNotEquals(integerMapGenotype, other); + assertTrue(other.isEmpty()); + other.setValue(mockup2, 2); + assertEquals(new Long(2), new Long(other.getValue(mockup2))); + assertEquals(new Long(1), new Long(other.getValue(mockup1))); + } + +} From c5e6bdb0abe04b30c0f86da955320745651e65bb Mon Sep 17 00:00:00 2001 From: Fedor Smirnov Date: Wed, 14 Feb 2018 19:53:56 +0100 Subject: [PATCH 4/4] adjusted uniqueness check --- .../java/org/opt4j/core/genotype/IntegerMapGenotype.java | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java b/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java index 637c4f42..fc199a84 100644 --- a/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java +++ b/opt4j-core/src/main/java/org/opt4j/core/genotype/IntegerMapGenotype.java @@ -70,10 +70,7 @@ public class IntegerMapGenotype extends IntegerGenotype implements MapGenotyp */ public IntegerMapGenotype(List list, Bounds bounds) { super(bounds); - Set uniqueKeys = new HashSet(); - for (K k : list) { - uniqueKeys.add(k); - } + Set uniqueKeys = new HashSet(list); if (uniqueKeys.size() < list.size()) { throw new IllegalArgumentException("The provided key objects have to be unique"); }