Add ParallelismValidation tests (#958)

src/test/java/com/pivovarit/collectors/test/BasicParallelismTest.java

@@ -1,38 +1,21 @@
 package com.pivovarit.collectors.test;
 
-import com.pivovarit.collectors.ParallelCollectors;
 import com.pivovarit.collectors.TestUtils;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.TestFactory;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import static com.pivovarit.collectors.test.Factory.GenericCollector.limitedCollector;
-import static com.pivovarit.collectors.test.Factory.e;
-import static java.util.stream.Collectors.collectingAndThen;
-import static java.util.stream.Collectors.toList;
+import static com.pivovarit.collectors.test.Factory.allBounded;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
 
 class BasicParallelismTest {
 
-    private static Stream<Factory.GenericCollector<Factory.CollectorFactoryWithParallelism<Integer, Integer>>> allBounded() {
-        return Stream.of(
-          limitedCollector("parallel(e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallel(f, e(), p), c -> c.join().toList())),
-          limitedCollector("parallel(toList(), e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallel(f, toList(), e(), p), CompletableFuture::join)),
-          limitedCollector("parallel(toList(), e, p) [batching]", (f, p) -> collectingAndThen(ParallelCollectors.Batching.parallel(f, toList(), e(), p), CompletableFuture::join)),
-          limitedCollector("parallelToStream(e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallelToStream(f, e(), p), Stream::toList)),
-          limitedCollector("parallelToStream(e, p) [batching]", (f, p) -> collectingAndThen(ParallelCollectors.Batching.parallelToStream(f, e(), p), Stream::toList)),
-          limitedCollector("parallelToOrderedStream(e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallelToOrderedStream(f, e(), p), Stream::toList)),
-          limitedCollector("parallelToOrderedStream(e, p) [batching]", (f, p) -> collectingAndThen(ParallelCollectors.Batching.parallelToOrderedStream(f, e(), p), Stream::toList))
-        );
-    }
-
     @TestFactory
     Stream<DynamicTest> shouldProcessEmptyWithMaxParallelism() {
         return Stream.of(1, 2, 4, 8, 16, 32, 64, 100)

src/test/java/com/pivovarit/collectors/test/Factory.java

@@ -13,6 +13,7 @@
 import static com.pivovarit.collectors.ParallelCollectors.Batching.parallel;
 import static com.pivovarit.collectors.test.Factory.GenericCollector.advancedCollector;
 import static com.pivovarit.collectors.test.Factory.GenericCollector.collector;
+import static com.pivovarit.collectors.test.Factory.GenericCollector.limitedCollector;
 import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.toList;
 
@@ -65,6 +66,22 @@ static Stream<Factory.GenericCollector<Factory.CollectorFactory<Integer, Integer
         );
     }
 
+    static Stream<Factory.GenericCollector<Factory.CollectorFactoryWithParallelism<Integer, Integer>>> allBounded() {
+        return Stream.of(
+          limitedCollector("parallel(p)", (f, p) -> collectingAndThen(ParallelCollectors.parallel(f, p), c -> c.join().toList())),
+          limitedCollector("parallel(e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallel(f, e(), p), c -> c.join().toList())),
+          limitedCollector("parallel(toList(), p)", (f, p) -> collectingAndThen(ParallelCollectors.parallel(f, toList(), p), CompletableFuture::join)),
+          limitedCollector("parallel(toList(), e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallel(f, toList(), e(), p), CompletableFuture::join)),
+          limitedCollector("parallel(toList(), e, p) [batching]", (f, p) -> collectingAndThen(ParallelCollectors.Batching.parallel(f, toList(), e(), p), CompletableFuture::join)),
+          limitedCollector("parallelToStream(p)", (f, p) -> collectingAndThen(ParallelCollectors.parallelToStream(f, p), Stream::toList)),
+          limitedCollector("parallelToStream(e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallelToStream(f, e(), p), Stream::toList)),
+          limitedCollector("parallelToStream(e, p) [batching]", (f, p) -> collectingAndThen(ParallelCollectors.Batching.parallelToStream(f, e(), p), Stream::toList)),
+          limitedCollector("parallelToOrderedStream(p)", (f, p) -> collectingAndThen(ParallelCollectors.parallelToOrderedStream(f, p), Stream::toList)),
+          limitedCollector("parallelToOrderedStream(e, p)", (f, p) -> collectingAndThen(ParallelCollectors.parallelToOrderedStream(f, e(), p), Stream::toList)),
+          limitedCollector("parallelToOrderedStream(e, p) [batching]", (f, p) -> collectingAndThen(ParallelCollectors.Batching.parallelToOrderedStream(f, e(), p), Stream::toList))
+        );
+    }
+
     public static Stream<GenericCollector<CollectorFactoryWithParallelismAndExecutor<Integer, Integer>>> boundedCollectors() {
         return Stream.of(
           advancedCollector("parallel()", (f, e, p) -> ParallelCollectors.parallel(f, e, p)),

src/test/java/com/pivovarit/collectors/test/ParallelismValidationTest.java

@@ -0,0 +1,22 @@
+package com.pivovarit.collectors.test;
+
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.TestFactory;
+
+import java.util.stream.Stream;
+
+import static com.pivovarit.collectors.test.Factory.allBounded;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class ParallelismValidationTest {
+
+    @TestFactory
+    Stream<DynamicTest> shouldRejectInvalidRejectedExecutionHandlerFactory() {
+        return allBounded()
+          .map(c -> DynamicTest.dynamicTest(c.name(), () -> {
+              assertThatThrownBy(() -> c.factory()
+                .collector(i -> i, -1))
+                .isInstanceOf(IllegalArgumentException.class);
+          }));
+    }
+}