benchmark preparations

app/src/main/java/de/uni_marburg/powersort/benchmark/DummyComparable1.java

@@ -3,9 +3,9 @@ package de.uni_marburg.powersort.benchmark;
 /**
  * A class for tiny, comparable objects.
  */
-record SomeComparable(int id) implements Comparable<SomeComparable> {
+record DummyComparable1(int id) implements Comparable<DummyComparable1> {
     @Override
-    public int compareTo(SomeComparable other) {
+    public int compareTo(DummyComparable1 other) {
         return id - other.id;
     }
 }

app/src/main/java/de/uni_marburg/powersort/benchmark/DummyComparable2.java

@@ -0,0 +1,18 @@
+package de.uni_marburg.powersort.benchmark;
+
+/**
+ * A class for tiny, comparable objects.
+ * <p>
+ * Prints to stdout when an object is created.
+ */
+record DummyComparable2(int id) implements Comparable<DummyComparable2> {
+    public DummyComparable2(int id) {
+        this.id = id;
+        System.out.println("Initialized " + this);
+    }
+
+    @Override
+    public int compareTo(DummyComparable2 other) {
+        return id - other.id;
+    }
+}

app/src/main/java/de/uni_marburg/powersort/benchmark/Educational.java

@@ -24,9 +24,9 @@ public class Educational {
      * eliminate the code duplication.
      */
     private static void sortObjectsAvoidingComparableTimSort() {
-        SomeComparable[] a = {
+        DummyComparable1[] a = {
-                new SomeComparable(1),
+                new DummyComparable1(1),
-                new SomeComparable(0)
+                new DummyComparable1(0)
         };
 
         NaturalOrder c = NaturalOrder.INSTANCE;
@@ -38,9 +38,9 @@ public class Educational {
     }
 
     public static void sortObjects() {
-        SomeComparable[] a = {
+        DummyComparable1[] a = {
-                new SomeComparable(1),
+                new DummyComparable1(1),
-                new SomeComparable(0)
+                new DummyComparable1(0)
         };
 
 

app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java

@@ -4,20 +4,21 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.List;
+import java.util.function.Supplier;
 
 public class Main {
     public static void main(final String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
-        final SomeComparable[] a = {
-                new SomeComparable(1),
-                new SomeComparable(0)
-        };
-
         final Method[] sortImplementations = getSortImplementations();
+        final List<Supplier<Object[]>> sortInputSuppliers = getSortInputSuppliers();
 
         final NaturalOrder c = NaturalOrder.INSTANCE;
-        for (Method sortImplementation : sortImplementations) {
+        for (Supplier<Object[]> sortInputSupplier : sortInputSuppliers) {
-            sortImplementation.invoke(null, a, 0, 0, c, null, 0, 0);
+            for (Method sortImplementation : sortImplementations) {
-            System.out.println(Arrays.toString(a));
+                Object[] sortInput = sortInputSupplier.get();
+                sortImplementation.invoke(null, sortInput, 0, 0, c, null, 0, 0);
+                System.out.println(Arrays.toString(sortInput));
+            }
         }
     }
 
@@ -27,4 +28,11 @@ public class Main {
                 DummySort2.class.getMethod("sort", Object[].class, int.class, int.class, Comparator.class, Object[].class, int.class, int.class)
         };
     }
+
+    static List<Supplier<Object[]>> getSortInputSuppliers() {
+        return Arrays.asList(
+                () -> new DummyComparable2[]{new DummyComparable2(0), new DummyComparable2(1)},
+                () -> new DummyComparable2[]{new DummyComparable2(2), new DummyComparable2(3)}
+        );
+    }
 }