Fix compile warnings.

jbgi · jbgi · commit 9f489c9428ff · 2018-10-08T10:12:04.000+02:00
diff --git a/core/src/test/java/fj/FWFunctionsTest.java b/core/src/test/java/fj/FWFunctionsTest.java
@@ -9,14 +9,14 @@ public class FWFunctionsTest {
     @Test
     public void testLift1() {
         F<Integer, Integer> f = i -> i + 1;
-        F1W f1w = F1W.lift(f);
+        F1W<Integer, Integer> f1w = F1W.lift(f);
         assertThat(f1w.f(1), is(2));
     }
 
     @Test
     public void testLift2() {
         F2<Integer, Integer, Integer> f2 = (i, j) -> i + j;
-        F2W f2w = F2W.lift(f2);
+        F2W<Integer, Integer, Integer> f2w = F2W.lift(f2);
         assertThat(f2w.f(1, 2), is(3));
     }
 
diff --git a/core/src/test/java/fj/TryEffectTest.java b/core/src/test/java/fj/TryEffectTest.java
@@ -11,17 +11,15 @@ public class TryEffectTest {
 
     @Test
     public void testTryEffect0Success() {
-        F<TryEffect0, Validation<TryEffectException, Unit>> f =
-                TryEffect.f(TryEffect0<TryEffectException>::f);
+        F<TryEffect0<TryEffectException>, Validation<TryEffectException, Unit>> f = TryEffect.f(TryEffect0::f);
         Validation<TryEffectException, Unit> v = f.f(new AlwaysSucceed0());
         assertThat(v.isSuccess(), is(true));
         assertThat(v.success(), is(Unit.unit()));
     }
 
     @Test
     public void testTryEffect0Fail() {
-        F<TryEffect0, Validation<TryEffectException, Unit>> f =
-                TryEffect.f(TryEffect0<TryEffectException>::f);
+        F<TryEffect0<TryEffectException>, Validation<TryEffectException, Unit>> f = TryEffect.f(TryEffect0::f);
         Validation<TryEffectException, Unit> v = f.f(new AlwaysFail0());
         assertThat(v.isFail(), is(true));
         assertThat(v.fail(), is(new TryEffectException()));
diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -3,6 +3,7 @@
 import fj.Ord;
 import fj.P;
 import fj.P1;
+import fj.Unit;
 import fj.data.Enumerator;
 import fj.data.List;
 import fj.data.Stream;
@@ -41,7 +42,7 @@ public void testStrategyExecutor() {
     public void testStrategyCompletion() {
         final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
         final ExecutorService es = Executors.newFixedThreadPool(10);
-        final CompletionService cs = new ExecutorCompletionService(es);
+        final CompletionService<Unit> cs = new ExecutorCompletionService<>(es);
         assertThat(s.sort(Ord.intOrd, completionStrategy(cs)), is(s.sort(Ord.intOrd)));
     }
 
diff --git a/props-core/src/test/java/fj/MemoisationTest.java b/props-core/src/test/java/fj/MemoisationTest.java
@@ -6,6 +6,7 @@
 import org.junit.runner.RunWith;
 
 import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbString;
 import static fj.test.CheckResult.summary;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
@@ -25,16 +26,16 @@ public Property test1() {
     }
 
     public Property test1_hardMemo() {
-        return property(arbInteger, a -> {
-            P1<Integer> t = P.hardMemo(() -> new Integer(a));
+        return property(arbString, a -> {
+            P1<String> t = P.hardMemo(() -> new String(a));
             return prop(t._1() == t._1()).and(prop(t._1().equals(a)));
         });
     }
 
     @Test
     public Property test2() {
-        return property(arbInteger, arbInteger, (a, b) -> {
-            P2<Integer, Integer> t = P.lazy(u -> new Integer(a), u -> new Integer(b)).memo();
+        return property(arbString, arbString, (a, b) -> {
+            P2<String, String> t = P.lazy(u ->  new String(a), u -> new String(b)).memo();
             return prop(t._1().equals(t._1()) && t._1().equals(a) && t._2().equals(t._2()) && t._2().equals(b) );
         });
     }
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -42,14 +42,16 @@ void validateOperations(List<Integer> list) {
     @Test
     public void testHeadOption() {
         assertThat(Empty.emptyIntAddition().headOption(), is(Option.none()));
-        FingerTree<Integer, Integer> ft = new MakeTree(measured(intAdditionMonoid, Function.constant(1))).single(1);
+        FingerTree<Integer, Integer> ft = new MakeTree<Integer, Integer>(measured(intAdditionMonoid, Function.constant(1)))
+            .single(1);
         assertThat(ft.headOption(), is(Option.some(1)));
     }
 
     @Test
     public void testUncons() {
         assertThat(Empty.emptyIntAddition().uncons(0, (h, t) -> h), is(0));
-        FingerTree<Integer, Integer> ft = new MakeTree(measured(intAdditionMonoid, Function.constant(1))).single(1);
+        FingerTree<Integer, Integer> ft = new MakeTree<Integer, Integer>(measured(intAdditionMonoid, Function.constant(1)))
+            .single(1);
         assertThat(ft.uncons(0, (h, t) -> h), is(1));
     }
 
