- F partial implementation of ParseInput with 3 parameters

Author: LarsEckart

approvaltests-tests/src/test/java/org/approvaltests/Parse3InputTest.java

@@ -0,0 +1,57 @@
+package org.approvaltests;
+
+import org.approvaltests.reporters.AutoApproveReporter;
+import org.approvaltests.reporters.UseReporter;
+import org.approvaltests.utils.parseinput.ParseInput;
+import org.junit.jupiter.api.Test;
+import org.lambda.query.Queryable;
+
+public class Parse3InputTest
+{
+  @Test
+  void testWithTypesTransformersAndBoth()
+  {
+    var expected = """
+      1,2.2,true -> 2.2
+      1,3.3,false -> 0.0
+      """;
+    ParseInput.from(expected).withTypes(Integer.class, Double.class, Boolean.class)
+            .verifyAll(t -> t.getFirst() * t.getSecond() * (t.getThird() ? 1 : 0));
+//    ParseInput.from(expected).withTypes(Integer.class, Double.class).verifyAll((i, d) -> i * d);
+//    ParseInput.from(expected).transformTo(Integer::parseInt, Double::parseDouble)
+//        .verifyAll(t -> t.getFirst() * t.getSecond());
+//    ParseInput.from(expected).withTypes(Integer.class, Double.class).transformTo((i, d) -> i * d)
+//        .verifyAll(t -> t);
+  }
+  @Test
+  void testPersonAge()
+  {
+    var expected = """
+        Llewellyn, 25 -> Person[
+            name=Llewellyn
+            label=adult
+        ]
+        Oliver, 15 -> Person[
+            name=Oliver
+            label=teenager
+        ]
+        """;
+    ParseInput.from(expected).multiline().withTypes(String.class, Integer.class).transformTo(Person::new)
+        .verifyAll(Person::toString);
+  }
+  @Test
+  @UseReporter(AutoApproveReporter.class)
+  public void testArrays()
+  {
+    var expected = """
+        1, 1 -> 2.0
+        10 ,1, 1 -> 12.0
+        5,5,7,7 -> 24.0
+        """;
+    ParseInput.from(expected).withTypes(Integer[].class).verifyAll(this::sum);
+  }
+  private Double sum(Integer[] integers)
+  {
+    return Queryable.of(integers).sum();
+  }
+}

approvaltests-util/src/main/java/com/spun/util/Tuple3.java

@@ -0,0 +1,31 @@
+package com.spun.util;
+
+public class Tuple3<H, K, L>
+{
+  private final H first;
+  private final K second;
+  private final L third;
+  public Tuple3(H first, K second, L third)
+  {
+    this.first = first;
+    this.second = second;
+    this.third = third;
+  }
+  public H getFirst()
+  {
+    return first;
+  }
+  public K getSecond()
+  {
+    return second;
+  }
+  public L getThird()
+  {
+    return third;
+  }
+  @Override
+  public String toString()
+  {
+    return String.format("<%s,%s,%s>", first, second, third);
+  }
+}

approvaltests/src/main/java/org/approvaltests/utils/parseinput/ParseInput.java

@@ -92,6 +92,16 @@ public <T1, T2> ParseInputWith2Parameters<T1, T2> transformTo(Function1<String,
   {
     return ParseInputWith2Parameters.create(expected, transformer1, transformer2, options);
   }
+  public <T1, T2, T3> ParseInputWith3Parameters<T1, T2, T3> withTypes(Class<T1> type1, Class<T2> type2, Class<T3> type3) {
+    return ParseInputWith3Parameters.create(
+            expected,
+            getTransformerForClass(type1),
+            getTransformerForClass(type2),
+            getTransformerForClass(type3),
+            options
+    );
+  }
+
   public static class ParseInputOptions
   {
     public final boolean multiline;

approvaltests/src/main/java/org/approvaltests/utils/parseinput/ParseInputWith3Parameters.java

@@ -0,0 +1,56 @@
+package org.approvaltests.utils.parseinput;
+
+import com.spun.util.Tuple;
+import com.spun.util.Tuple3;
+import org.lambda.functions.Function1;
+import org.lambda.functions.Function2;
+import org.lambda.functions.Function3;
+import org.lambda.query.Queryable;
+
+public class ParseInputWith3Parameters<IN1, IN2, IN3>
+{
+    private final String                                 expected;
+    private final Function1<String, Tuple3<IN1, IN2, IN3>> transformer;
+    private final ParseInput.ParseInputOptions           options;
+
+    public ParseInputWith3Parameters(String expected, Function1<String, Tuple3<IN1, IN2, IN3>> transformer,
+                                     ParseInput.ParseInputOptions options)
+    {
+        this.expected = expected;
+        this.transformer = transformer;
+        this.options = options;
+    }
+
+    public static <IN1, IN2, IN3> ParseInputWith3Parameters<IN1, IN2, IN3> create(String expected,
+                                                                                  Function1<String, IN1> t1, Function1<String, IN2> t2, Function1<String, IN3> t3,
+                                                                                  ParseInput.ParseInputOptions options)
+    {
+        Function1<String, Tuple3<IN1, IN2, IN3>> f = s -> {
+            Queryable<String> temp = Queryable.as(s.split(",")).select(String::trim);
+            IN1 v1 = t1.call(temp.get(0));
+            IN2 v2 = t2.call(temp.get(1));
+            IN3 v3 = t3.call(temp.get(2));
+            return new Tuple3<>(v1, v2, v3);
+        };
+        return new ParseInputWith3Parameters<>(expected, f, options);
+    }
+
+    private ParseInput<Tuple3<IN1, IN2, IN3>> getParseInput()
+    {
+        return new ParseInput<>(expected, s -> new Tuple<>(s, transformer.call(s)), options);
+    }
+
+//    public <OUT> ParseInputWith1Parameters<OUT> transformTo(Function3<Tuple3<IN1, IN2, IN3>, OUT> transform)
+//    {
+//        Function1<String, OUT> f1 = (t) -> {
+//            Tuple3<IN1, IN2, IN3> transformed = transformer.call(t);
+//            return transform.call(transformed);
+//        };
+//        return new ParseInputWith1Parameters<>(expected, f1, options);
+//    }
+
+    public void verifyAll(Function1<Tuple3<IN1, IN2, IN3>, Object> transform)
+    {
+        getParseInput().verifyAll(transform);
+    }
+}