Merge 30077d0 into 562a8ee

opt4j-core/build.gradle

@@ -4,6 +4,7 @@ dependencies {
 	compile	group: 'com.google.inject', name: 'guice', version: '4.2.1'
 
 	testCompile	group: 'junit', name: 'junit', version: '4.12'
+	testCompile group: 'org.mockito', name: 'mockito-core', version: '2.22.0'
 }
 
 processResources {

opt4j-core/src/test/java/org/opt4j/core/common/archive/BoundedArchiveTest.java

@@ -0,0 +1,138 @@
+package org.opt4j.core.common.archive;
+
+import static org.mockito.Mockito.mock;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.opt4j.core.Individual;
+
+public class BoundedArchiveTest {
+	@Test(expected = IllegalArgumentException.class)
+	public void boundedArchiveIllegalCapacity() {
+		BoundedArchive archive = new BoundedArchive(-1) {
+
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				Assert.fail();
+				return false;
+			}
+		};
+		Assert.fail("should not be creatable: " + archive);
+	}
+
+	@Test
+	public void setCapacity() {
+		BoundedArchive archive = new BoundedArchive(10) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				Assert.fail();
+				return false;
+			}
+		};
+		Assert.assertEquals(10, archive.getCapacity());
+		archive.setCapacity(20);
+		Assert.assertEquals(20, archive.getCapacity());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void setCapacityIllegalCapacity() {
+		BoundedArchive archive = new BoundedArchive(10) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				Assert.fail();
+				return false;
+			}
+		};
+		archive.setCapacity(-1);
+	}
+
+	@Test
+	public void addCheckedIndividual() {
+		Individual individual1 = mock(Individual.class);
+
+		BoundedArchive archive = new BoundedArchive(1) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				individuals.addAll(candidates);
+				return true;
+			}
+		};
+		archive.addCheckedIndividual(individual1);
+		Assert.assertTrue(archive.contains(individual1));
+		Assert.assertEquals(1, archive.size());
+	}
+
+	@Test
+	public void addCheckedIndividualTwice() {
+		Individual individual1 = mock(Individual.class);
+
+		BoundedArchive archive = new BoundedArchive(1) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				individuals.addAll(candidates);
+				return true;
+			}
+		};
+		archive.addCheckedIndividual(individual1);
+		archive.addCheckedIndividual(individual1);
+		Assert.assertTrue(archive.contains(individual1));
+		Assert.assertEquals(1, archive.size());
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void addCheckedIndividualDespiteArchiveFull() {
+		Individual individual1 = mock(Individual.class);
+		Individual individual2 = mock(Individual.class);
+
+		BoundedArchive archive = new BoundedArchive(1) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				individuals.addAll(candidates);
+				return true;
+			}
+		};
+		archive.addCheckedIndividual(individual1);
+		Assert.assertTrue(archive.contains(individual1));
+		Assert.assertEquals(1, archive.size());
+
+		archive.addCheckedIndividual(individual2);
+	}
+
+	@Test
+	public void addCheckedIndividuals() {
+		Individual individual1 = mock(Individual.class);
+
+		BoundedArchive archive = new BoundedArchive(1) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				individuals.addAll(candidates);
+				return true;
+			}
+		};
+		archive.addCheckedIndividuals(Collections.singleton(individual1));
+		Assert.assertTrue(archive.contains(individual1));
+		Assert.assertEquals(1, archive.size());
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void addCheckedIndividualsDespiteArchiveFull() {
+		Individual individual1 = mock(Individual.class);
+		Individual individual2 = mock(Individual.class);
+
+		BoundedArchive archive = new BoundedArchive(1) {
+			@Override
+			protected boolean updateWithNondominated(Collection<Individual> candidates) {
+				individuals.addAll(candidates);
+				return true;
+			}
+		};
+		archive.addCheckedIndividuals(Collections.singleton(individual1));
+		Assert.assertTrue(archive.contains(individual1));
+		Assert.assertEquals(1, archive.size());
+
+		archive.addCheckedIndividuals(Collections.singleton(individual2));
+	}
+}

opt4j-core/src/test/java/org/opt4j/core/common/archive/UnboundedArchiveTest.java

@@ -0,0 +1,38 @@
+package org.opt4j.core.common.archive;
+
+import static org.mockito.Mockito.mock;
+
+import java.util.Collections;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.opt4j.core.Individual;
+
+public class UnboundedArchiveTest {
+
+	@Test
+	public void updateWithNondominated() {
+		Individual individual = mock(Individual.class);
+
+		UnboundedArchive archive = new UnboundedArchive();
+		Assert.assertFalse(archive.iterator().hasNext());
+		Assert.assertTrue(archive.updateWithNondominated(Collections.singleton(individual)));
+		Assert.assertTrue(archive.iterator().hasNext());
+		Assert.assertEquals(archive.iterator().next(), individual);
+	}
+
+	@Test
+	public void updateWithExisting() {
+		Individual individual = mock(Individual.class);
+
+		UnboundedArchive archive = new UnboundedArchive();
+		archive.updateWithNondominated(Collections.singleton(individual));
+		Assert.assertFalse(archive.updateWithNondominated(Collections.singleton(individual)));
+	}
+
+	@Test
+	public void updateWithNone() {
+		UnboundedArchive archive = new UnboundedArchive();
+		Assert.assertFalse(archive.updateWithNondominated(Collections.<Individual> emptySet()));
+	}
+}