extract inline definitions of generators, add loop for different sizes

primitiveCollections/src/test/java/org/lucares/collections/BenchmarkHarness.java

@@ -19,6 +19,66 @@ public class BenchmarkHarness<T> {
 		void run(T input);
 	}
 
+	static class SortedListGenerator implements Generator<IntList> {
+
+		private final int size;
+
+		public SortedListGenerator(final int size) {
+			this.size = size;
+		}
+
+		@Override
+		public IntList generateInput() {
+
+			final IntList result = IntList.of();
+			IntStream.range(0, size).forEachOrdered(i -> result.add(i));
+			result.sort();
+			return result;
+		}
+	};
+
+	static class UnsortedListGenerator implements Generator<IntList> {
+
+		private final int size;
+
+		public UnsortedListGenerator(final int size) {
+			this.size = size;
+		}
+
+		@Override
+		public IntList generateInput() {
+			final SortedListGenerator sortedListGenerator = new SortedListGenerator(size);
+			final IntList list = sortedListGenerator.generateInput();
+			list.shuffle();
+			return list;
+		}
+	};
+
+	static class ListPairGenerator implements Generator<IntListPair> {
+
+		private final Generator<IntList> generatorA;
+		private final Generator<IntList> generatorB;
+
+		public ListPairGenerator(final Generator<IntList> generator) {
+			this(generator, generator);
+		}
+
+		public ListPairGenerator(final Generator<IntList> generatorA, final Generator<IntList> generatorB) {
+			this.generatorA = generatorA;
+			this.generatorB = generatorB;
+		}
+
+		@Override
+		public IntListPair generateInput() {
+			final IntListPair result = new IntListPair();
+
+			result.a = generatorA.generateInput();
+			result.b = generatorB.generateInput();
+
+			return result;
+		}
+	}
+
 	public <P> void test(final String name, final Generator<P> generator, final Invocation<P> invoker,
 			final int iterations) {
 
@@ -45,44 +105,25 @@ public class BenchmarkHarness<T> {
 	public static void main(final String[] args) {
 		final BenchmarkHarness<Object> harness = new BenchmarkHarness<>();
 
-		final Generator<IntList> generatorSorted = () -> {
-			final int values = 100_000;
-			final IntList result = IntList.of();
-			IntStream.range(0, values).forEachOrdered(i -> result.add(i));
-			result.sort();
-			return result;
-		};
-		final Generator<IntList> generatorUnsorted = () -> {
-			final IntList result = generatorSorted.generateInput();
-			result.shuffle();
-			return result;
-		};
+		final IntList sizes = IntList.of(10, 100, 1000, 10_000, 100_000);
 
-		final Generator<IntListPair> generatorSortedPair = () -> {
-			final IntListPair result = new IntListPair();
+		for (int l = 0; l < sizes.size(); l++) {
 
-			result.a = generatorSorted.generateInput();
-			result.b = generatorSorted.generateInput();
+			final int size = sizes.get(l);
 
-			return result;
-		};
+			final Generator<IntList> generatorSorted = new SortedListGenerator(size);
+			final Generator<IntList> generatorUnsorted = new UnsortedListGenerator(size);
+			final Generator<IntListPair> generatorSortedPair = new ListPairGenerator(generatorSorted);
+			final Generator<IntListPair> generatorUnsortedPair = new ListPairGenerator(generatorUnsorted);
 
-		final Generator<IntListPair> generatorUnsortedPair = () -> {
-			final IntListPair result = new IntListPair();
+			final Invocation<IntListPair> union = p -> IntList.union(p.a, p.b);
 
-			result.a = generatorUnsorted.generateInput();
-			result.b = generatorUnsorted.generateInput();
-
-			return result;
-		};
-
-		final Invocation<IntListPair> union = p -> IntList.union(p.a, p.b);
-
-		for (int i = 0; i < 10; i++) {
-			harness.test("union(): unsorted" + i, generatorUnsortedPair, union, 100);
-		}
-		for (int i = 0; i < 10; i++) {
-			harness.test("union(): sorted" + i, generatorSortedPair, union, 100);
+			for (int i = 0; i < 5; i++) {
+				harness.test("union(" + size + "): unsorted" + i, generatorUnsortedPair, union, 100);
+			}
+			for (int i = 0; i < 5; i++) {
+				harness.test("union(" + size + "): sorted" + i, generatorSortedPair, union, 100);
+			}
 		}
 	}
 }