use diamond operator

SDARG · Sep 26, 2018 · 53f13bc · 53f13bc
1 parent b8a613e
commit 53f13bc
Show file tree

Hide file tree

Showing 11 changed files with 181 additions and 202 deletions.
diff --git a/opt4j-benchmarks/src/main/java/org/opt4j/benchmarks/dtlz/DTLZ1.java b/opt4j-benchmarks/src/main/java/org/opt4j/benchmarks/dtlz/DTLZ1.java
@@ -8,8 +8,8 @@
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
@@ -19,7 +19,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *******************************************************************************/
-
 
 package org.opt4j.benchmarks.dtlz;
 
@@ -63,7 +62,7 @@ public DTLZ1(@M int m, @N int n) {
 	 */
 	@Override
 	protected List<Double> f(List<Double> x, double g) {
-		List<Double> f = new ArrayList<Double>();
+		List<Double> f = new ArrayList<>();
 
 		double a = 1.0 / 2.0 * (1.0 + g);
 

diff --git a/opt4j-core/src/test/java/org/opt4j/core/DefaultIndividualFactoryTest.java b/opt4j-core/src/test/java/org/opt4j/core/DefaultIndividualFactoryTest.java
@@ -1,27 +1,14 @@
 package org.opt4j.core;
 
 import org.opt4j.core.genotype.PermutationGenotype;
-import org.opt4j.core.problem.Creator;
-
-import com.google.inject.Provider;
 
 public class DefaultIndividualFactoryTest extends AbstractIndividualFactoryTest {
 	protected Individual individual = new Individual();
-	protected PermutationGenotype<Object> genotype = new PermutationGenotype<Object>();
+	protected PermutationGenotype<Object> genotype = new PermutationGenotype<>();
 
 	@Override
 	public AbstractIndividualFactory<Individual> getFactory() {
-		return new DefaultIndividualFactory(new Provider<Individual>() {
-			@Override
-			public Individual get() {
-				return individual;
-			}
-		}, new Creator<Genotype>() {
-			@Override
-			public Genotype create() {
-				return genotype;
-			}
-		});
+		return new DefaultIndividualFactory(() -> individual, () -> genotype);
 	}
 
 }
diff --git a/opt4j-core/src/test/java/org/opt4j/core/genotype/BooleanMapGenotypeTest.java b/opt4j-core/src/test/java/org/opt4j/core/genotype/BooleanMapGenotypeTest.java
@@ -1,6 +1,9 @@
 package org.opt4j.core.genotype;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -30,31 +33,31 @@ public MockList() {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testInvalidKeyGetIndex() {
-		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<Integer>(new MockList());
+		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<>(new MockList());
 		geno.getIndexOf(3);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testInvalidKeySetValue() {
-		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<Integer>(new MockList());
+		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<>(new MockList());
 		geno.setValue(3, true);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testInvalidKeyGetValue() {
-		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<Integer>(new MockList());
+		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<>(new MockList());
 		geno.getValue(3);
 	}
 
 	@Test(expected = UnsupportedOperationException.class)
 	public void testWrongInit() {
-		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<Integer>(new MockList());
+		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<>(new MockList());
 		geno.init(new MockRandom(), 2);
 	}
 
 	@Test
 	public void testConstructor() {
-		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<Integer>(new MockList());
+		BooleanMapGenotype<Integer> geno = new BooleanMapGenotype<>(new MockList());
 		assertTrue(geno.isEmpty());
 		geno.setValue(1, true);
 		assertEquals(1, geno.size());
@@ -66,7 +69,7 @@ public void testConstructor() {
 		assertTrue(geno.containsKey(1));
 		assertFalse(geno.containsKey(3));
 		assertEquals(0, geno.getIndexOf(1));
-		Set<Integer> keys = new HashSet<Integer>(geno.getKeys());
+		Set<Integer> keys = new HashSet<>(geno.getKeys());
 		assertEquals(2, keys.size());
 		assertTrue(keys.contains(1));
 		assertTrue(keys.contains(2));
@@ -78,10 +81,10 @@ public void testConstructor() {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testNonUniqueKeys() {
-		List<Integer> keyList = new ArrayList<Integer>();
+		List<Integer> keyList = new ArrayList<>();
 		keyList.add(1);
 		keyList.add(1);
-		new BooleanMapGenotype<Integer>(keyList);
+		new BooleanMapGenotype<>(keyList);
 	}
 
 }
diff --git a/opt4j-core/src/test/java/org/opt4j/core/genotype/DoubleMapGenotypeTest.java b/opt4j-core/src/test/java/org/opt4j/core/genotype/DoubleMapGenotypeTest.java
@@ -1,6 +1,9 @@
 package org.opt4j.core.genotype;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -41,18 +44,22 @@ public int hashCode() {
 
 		@Override
 		public boolean equals(Object obj) {
-			if (this == obj)
+			if (this == obj) {
 				return true;
-			if (obj == null)
+			}
+			if (obj == null) {
 				return false;
-			if (getClass() != obj.getClass())
+			}
+			if (getClass() != obj.getClass()) {
 				return false;
+			}
 			MockObject other = (MockObject) obj;
-			if (!getOuterType().equals(other.getOuterType()))
+			if (!getOuterType().equals(other.getOuterType())) {
 				return false;
+			}
 			return field == other.field;
 		}
-		
+
 		@Override
 		public String toString() {
 			return "m" + field;
@@ -62,163 +69,152 @@ private DoubleMapGenotypeTest getOuterType() {
 			return DoubleMapGenotypeTest.this;
 		}
 	}
-	
-	@Test(expected=UnsupportedOperationException.class)
-	public void testWrongInitCall(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+
+	@Test(expected = UnsupportedOperationException.class)
+	public void testWrongInitCall() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
 		DoubleBounds bounds = new DoubleBounds(lower2, upper);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				bounds);
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, bounds);
 		doubleMapGeno.init(new Random(), 10);
 	}
-	
+
 	@Test
-	public void testSetValue(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+	public void testSetValue() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
 		DoubleBounds bounds = new DoubleBounds(lower2, upper);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				bounds);
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, bounds);
 		doubleMapGeno.setValue(m2, 0.4);
 		assertEquals(0.4, doubleMapGeno.getValue(m2), 0.0);
 		doubleMapGeno.init(new Random());
 		doubleMapGeno.setValue(m1, 0.5);
 		assertEquals(0.5, doubleMapGeno.getValue(m1), 0.0);
 	}
-	
-	@Test(expected=IllegalArgumentException.class)
-	public void testSetValueOutOfBounds2(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetValueOutOfBounds2() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		doubleMapGeno.setValue(m1, -2.0);
 	}
-	
-	@Test(expected=IllegalArgumentException.class)
-	public void testSetValueOutOfBounds1(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetValueOutOfBounds1() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		doubleMapGeno.setValue(m1, 2.0);
 	}
-	
-	@Test(expected=IllegalArgumentException.class)
-	public void testSetValueInvalidKey(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetValueInvalidKey() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		MockObject m3 = new MockObject(3);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		doubleMapGeno.setValue(m3, 1.0);
 	}
-	
+
 	@Test
-	public void testNewInstance(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+	public void testNewInstance() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		doubleMapGeno.init(new Random());
 		DoubleMapGenotype<MockObject> other = doubleMapGeno.newInstance();
 		assertNotEquals(doubleMapGeno, other);
 		assertTrue(other.isEmpty());
 	}
-	
+
 	@Test
-	public void testToString(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+	public void testToString() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		doubleMapGeno.init(new Random());
 		assertEquals("[m1=1.0;m2=1.0;]", doubleMapGeno.toString());
 	}
-	
+
 	@Test
-	public void testGetIndexOf(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+	public void testGetIndexOf() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		assertEquals(0, doubleMapGeno.getIndexOf(m1));
 	}
-	
+
 	@Test(expected = IllegalArgumentException.class)
-	public void testGetIndexOfInvalidKey(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+	public void testGetIndexOfInvalidKey() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		MockObject m3 = new MockObject(3);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		doubleMapGeno.getIndexOf(m3);
 	}
 
 	@Test
-	public void testGetKeys(){
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+	public void testGetKeys() {
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		Collection<MockObject> ks = doubleMapGeno.getKeys();
 		assertEquals(2, ks.size());
 		assertTrue(ks.contains(m1));
 		assertTrue(ks.contains(m2));
 	}
-	
+
 	@Test()
 	public void testContainsKey() {
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		MockObject m2 = new MockObject(2);
 		MockObject m3 = new MockObject(3);
 		keys.add(m1);
 		keys.add(m2);
-		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<DoubleMapGenotypeTest.MockObject>(keys,
-				new MockBounds());
+		DoubleMapGenotype<MockObject> doubleMapGeno = new DoubleMapGenotype<>(keys, new MockBounds());
 		assertTrue(doubleMapGeno.containsKey(m1));
 		assertFalse(doubleMapGeno.containsKey(m3));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testNonUniqueKeys() {
-		List<MockObject> keys = new ArrayList<DoubleMapGenotypeTest.MockObject>();
+		List<MockObject> keys = new ArrayList<>();
 		MockObject m1 = new MockObject(1);
 		keys.add(m1);
 		keys.add(m1);
-		new DoubleMapGenotype<MockObject>(keys, new MockBounds());
+		new DoubleMapGenotype<>(keys, new MockBounds());
 	}
 
 }