Java 11 migrate 7 remaining f (#1115)

* Moves facade to Java 11

* Moves factory-kit to Java 11

* Moves factory-method to Java 11

* Moves feature-toggle to Java 11

* Moves fluentinterface to Java 11

* Moves flux to Java 11

* Moves flyweight to Java 11

* Moves front-controller to Java 11

* Uses stream properly

* Resolves issues with ci

fluentinterface/src/test/java/com/iluwatar/fluentinterface/app/AppTest.java

@@ -32,7 +32,6 @@ public class AppTest {
 
   @Test
   public void test() {
-    String[] args = {};
-    App.main(args);
+    App.main(new String[]{});
   }
 }

fluentinterface/src/test/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterableTest.java

@@ -23,16 +23,19 @@
 
 package com.iluwatar.fluentinterface.fluentiterable;
 
-import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.util.Collections;
 import java.util.List;
-import java.util.Optional;
-import java.util.Spliterator;
 import java.util.function.Consumer;
-
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import org.junit.jupiter.api.Test;
 
 /**
  * Date: 12/12/15 - 7:00 PM
@@ -50,28 +53,28 @@ public abstract class FluentIterableTest {
   protected abstract FluentIterable<Integer> createFluentIterable(final Iterable<Integer> integers);
 
   @Test
-  public void testFirst() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3, 10, 9, 8);
-    final Optional<Integer> first = createFluentIterable(integers).first();
+  public void testFirst() {
+    final var integers = List.of(1, 2, 3, 10, 9, 8);
+    final var first = createFluentIterable(integers).first();
     assertNotNull(first);
     assertTrue(first.isPresent());
     assertEquals(integers.get(0), first.get());
   }
 
   @Test
-  public void testFirstEmptyCollection() throws Exception {
-    final List<Integer> integers = Collections.emptyList();
-    final Optional<Integer> first = createFluentIterable(integers).first();
+  public void testFirstEmptyCollection() {
+    final var integers = Collections.<Integer>emptyList();
+    final var first = createFluentIterable(integers).first();
     assertNotNull(first);
     assertFalse(first.isPresent());
   }
 
   @Test
-  public void testFirstCount() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3, 10, 9, 8);
-    final List<Integer> first4 = createFluentIterable(integers)
-            .first(4)
-            .asList();
+  public void testFirstCount() {
+    final var integers = List.of(1, 2, 3, 10, 9, 8);
+    final var first4 = createFluentIterable(integers)
+        .first(4)
+        .asList();
 
     assertNotNull(first4);
     assertEquals(4, first4.size());
@@ -83,11 +86,11 @@ public abstract class FluentIterableTest {
   }
 
   @Test
-  public void testFirstCountLessItems() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3);
-    final List<Integer> first4 = createFluentIterable(integers)
-            .first(4)
-            .asList();
+  public void testFirstCountLessItems() {
+    final var integers = List.of(1, 2, 3);
+    final var first4 = createFluentIterable(integers)
+        .first(4)
+        .asList();
 
     assertNotNull(first4);
     assertEquals(3, first4.size());
@@ -98,28 +101,28 @@ public abstract class FluentIterableTest {
   }
 
   @Test
-  public void testLast() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3, 10, 9, 8);
-    final Optional<Integer> last = createFluentIterable(integers).last();
+  public void testLast() {
+    final var integers = List.of(1, 2, 3, 10, 9, 8);
+    final var last = createFluentIterable(integers).last();
     assertNotNull(last);
     assertTrue(last.isPresent());
     assertEquals(integers.get(integers.size() - 1), last.get());
   }
 
   @Test
-  public void testLastEmptyCollection() throws Exception {
-    final List<Integer> integers = Collections.<Integer>emptyList();
-    final Optional<Integer> last = createFluentIterable(integers).last();
+  public void testLastEmptyCollection() {
+    final var integers = Collections.<Integer>emptyList();
+    final var last = createFluentIterable(integers).last();
     assertNotNull(last);
     assertFalse(last.isPresent());
   }
 
   @Test
-  public void testLastCount() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3, 10, 9, 8);
-    final List<Integer> last4 = createFluentIterable(integers)
-            .last(4)
-            .asList();
+  public void testLastCount() {
+    final var integers = List.of(1, 2, 3, 10, 9, 8);
+    final var last4 = createFluentIterable(integers)
+        .last(4)
+        .asList();
 
     assertNotNull(last4);
     assertEquals(4, last4.size());
@@ -130,11 +133,11 @@ public abstract class FluentIterableTest {
   }
 
   @Test
-  public void testLastCountLessItems() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3);
-    final List<Integer> last4 = createFluentIterable(integers)
-            .last(4)
-            .asList();
+  public void testLastCountLessItems() {
+    final var integers = List.of(1, 2, 3);
+    final var last4 = createFluentIterable(integers)
+        .last(4)
+        .asList();
 
     assertNotNull(last4);
     assertEquals(3, last4.size());
@@ -145,11 +148,11 @@ public abstract class FluentIterableTest {
   }
 
   @Test
-  public void testFilter() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3, 10, 9, 8);
-    final List<Integer> evenItems = createFluentIterable(integers)
-            .filter(i -> i % 2 == 0)
-            .asList();
+  public void testFilter() {
+    final var integers = List.of(1, 2, 3, 10, 9, 8);
+    final var evenItems = createFluentIterable(integers)
+        .filter(i -> i % 2 == 0)
+        .asList();
 
     assertNotNull(evenItems);
     assertEquals(3, evenItems.size());
@@ -159,11 +162,11 @@ public abstract class FluentIterableTest {
   }
 
   @Test
-  public void testMap() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3);
-    final List<Long> longs = createFluentIterable(integers)
-            .map(Integer::longValue)
-            .asList();
+  public void testMap() {
+    final var integers = List.of(1, 2, 3);
+    final var longs = createFluentIterable(integers)
+        .map(Integer::longValue)
+        .asList();
 
     assertNotNull(longs);
     assertEquals(integers.size(), longs.size());
@@ -174,7 +177,7 @@ public abstract class FluentIterableTest {
 
   @Test
   public void testForEach() {
-    final List<Integer> integers = List.of(1, 2, 3);
+    final var integers = List.of(1, 2, 3);
 
     final Consumer<Integer> consumer = mock(Consumer.class);
     createFluentIterable(integers).forEach(consumer);
@@ -188,8 +191,8 @@ public abstract class FluentIterableTest {
 
   @Test
   public void testSpliterator() throws Exception {
-    final List<Integer> integers = List.of(1, 2, 3);
-    final Spliterator<Integer> split = createFluentIterable(integers).spliterator();
+    final var integers = List.of(1, 2, 3);
+    final var split = createFluentIterable(integers).spliterator();
     assertNotNull(split);
   }