- F multiline support when 1 input

Author: LarsEckart

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

@@ -1,9 +1,12 @@
 package org.approvaltests;
 
+import com.spun.util.JsonUtils;
 import org.approvaltests.core.Options;
 import org.junit.jupiter.api.Test;
 import org.lambda.query.Queryable;
 
+import static java.lang.Integer.parseInt;
+
 public class Parse1InputTest
 {
   @Test
@@ -32,4 +35,20 @@ void testWithTypesTransformersAndBoth()
     Queryable<Integer> inputs = ParseInput.from(expected).withTypes(Integer.class).getInputs();
     Approvals.verifyAll(inputs, i -> i + " -> " + Integer.toBinaryString(i), new Options().inline(expected));
   }
+  @Test
+  void testMultiLineSupport()
+  {
+    var expected = """
+      1 -> {
+        "name": "name",
+        "age": 1
+      }
+      9 -> {
+        "name": "name",
+        "age": 9
+      }
+      """;
+    ParseInput.from(expected).multiline().verifyAll(s -> JsonUtils.asJson(new Person("name", Integer.parseInt(s))));
+    ParseInput.from(expected).multiline().withTypes(Integer.class).transformTo(i -> new Person("name", i)).verifyAll(s -> JsonUtils.asJson(s));
+  }
 }

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

@@ -13,19 +13,21 @@ public class ParseInput<OUT>
   private final String                                expected;
   private final Function1<String, Tuple<String, OUT>> transformer;
   private boolean                                     multiline;
-  public static ParseInput<String> from(String expected)
+  public ParseInput(String expected, Function1<String, Tuple<String, OUT>> transformer, boolean multiline)
   {
-    return new ParseInput<String>(expected, s -> new Tuple<>(s, s));
+    this.expected = expected;
+    this.transformer = transformer;
+    this.multiline = multiline;
   }
-  public static <OUT> ParseInput<OUT> from(String expected, Function1<String, OUT> transformer)
+  ParseInput(String expected, Function1<String, Tuple<String, OUT>> transformer)
   {
-    return new ParseInput<OUT>(expected, s -> new Tuple<>(s, transformer.call(s)));
+    this(expected, transformer, false);
   }
-  private ParseInput(String expected, Function1<String, Tuple<String, OUT>> transformer)
+  public static ParseInput<String> from(String expected)
   {
-    this.expected = expected;
-    this.transformer = transformer;
+    return new ParseInput<String>(expected, s -> new Tuple<>(s, s));
   }
+
   public static <OUT> ParseInput<OUT> create(String expected, Function1<Queryable<String>, OUT> transformer)
   {
     return new ParseInput<OUT>(expected, s -> {
@@ -49,11 +51,11 @@ public static <IN1, IN2, OUT> ParseInput<OUT> create(String expected, Function2<
   public static <OUT> ParseInput<OUT> from(String expected, Class<OUT> tranformTo)
   {
     Function1<String, OUT> transformer1 = getTransformerForClass(tranformTo);
-    return ParseInput.from(expected, transformer1);
+    return new ParseInput<OUT>(expected, s -> new Tuple<>(s, transformer1.call(s)));
   }
   public <OUT> ParseInputWith1Parameters<OUT> withTypes(Class<OUT> type1)
   {
-    return ParseInputWith1Parameters.create(expected, type1);
+    return ParseInputWith1Parameters.create(expected, type1, multiline);
   }
   //  public <OUT> ParseInput<OUT> transformTo(Function1<String, OUT> transformer)
   //  {
@@ -96,21 +98,21 @@ public void verifyAll(Function1<OUT, Object> transform)
   }
   public <T1, T2> ParseInputWith2Parameters<T1, T2, Tuple<T1, T2>> withTypes(Class<T1> type1, Class<T2> type2)
   {
-    return ParseInputWith2Parameters.create(expected, type1, type2);
+    return ParseInputWith2Parameters.create(expected, getTransformerForClass(type1),
+        getTransformerForClass(type2));
   }
-  public <T1, T2>  ParseInputWith2Parameters<T1, T2, Tuple<T1, T2>> transformTo(Function1<String, T1> transformer1, Function1<String, T2> transformer2)
+  public <T1, T2> ParseInputWith2Parameters<T1, T2, Tuple<T1, T2>> transformTo(Function1<String, T1> transformer1,
+      Function1<String, T2> transformer2)
   {
     return ParseInputWith2Parameters.create(expected, transformer1, transformer2);
-
   }
   public ParseInput<OUT> multiline()
   {
-    this.multiline = true;
-    return this;
+    return new ParseInput<>(expected, transformer, true);
   }
   public <OUT> ParseInputWith1Parameters<OUT> transformTo(Function1<String, OUT> transformer)
   {
-    return new ParseInputWith1Parameters<>(expected, transformer);
+    return new ParseInputWith1Parameters<>(expected, transformer, multiline);
   }
   public Queryable<OUT> getInputs()
   {

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

@@ -1,32 +1,37 @@
 package org.approvaltests;
 
+import com.spun.util.Tuple;
 import org.lambda.functions.Function1;
 import org.lambda.query.Queryable;
 
 public class ParseInputWith1Parameters<OUT>
 {
   private final String                 expected;
   private final Function1<String, OUT> transformer;
-  public ParseInputWith1Parameters(String expected, Function1<String, OUT> transformer)
+  private final boolean                multiline;
+  public ParseInputWith1Parameters(String expected, Function1<String, OUT> transformer, boolean multiline)
   {
     this.expected = expected;
     this.transformer = transformer;
+    this.multiline = multiline;
   }
-  public static <OUT> ParseInputWith1Parameters<OUT> create(String expected, Class<OUT> type1)
+  public static <OUT> ParseInputWith1Parameters<OUT> create(String expected, Class<OUT> type1, boolean multiline)
   {
-    return new ParseInputWith1Parameters<>(expected, ParseInput.getTransformerForClass(type1));
+    return new ParseInputWith1Parameters<>(expected, ParseInput.getTransformerForClass(type1), multiline);
   }
   public <OUT2> ParseInputWith1Parameters<OUT2> transformTo(Function1<OUT, OUT2> transformer1)
   {
     Function1<String, OUT2> transformer2 = (String t) -> transformer1.call(transformer.call(t));
-    return new ParseInputWith1Parameters<>(expected, transformer2);
+    return new ParseInputWith1Parameters<>(expected, transformer2, multiline);
   }
   public void verifyAll(Function1<OUT, Object> transform)
   {
-    ParseInput.from(expected, transformer).verifyAll(transform);
+    new ParseInput<OUT>(expected, s -> new Tuple<>(s, transformer.call(s)), multiline).verifyAll(transform);
   }
   public Queryable<OUT> getInputs()
   {
-    return ParseInput.from(expected, transformer).parse().select(t -> t.getSecond());
+    ParseInput<OUT> parseInput = new ParseInput<OUT>(expected, s -> new Tuple<>(s, transformer.call(s)),
+        multiline);
+    return parseInput.parse().select(t -> t.getSecond());
   }
 }

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

@@ -4,8 +4,6 @@
 import org.lambda.functions.Function1;
 import org.lambda.query.Queryable;
 
-import static org.approvaltests.ParseInput.getTransformerForClass;
-
 public class ParseInputWith2Parameters<IN1, IN2, OUT>
 {
   private final String                 expected;
@@ -15,13 +13,7 @@ public ParseInputWith2Parameters(String expected, Function1<String, OUT> transfo
     this.expected = expected;
     this.transformer = transformer;
   }
-  public static <IN1, IN2> ParseInputWith2Parameters<IN1, IN2, Tuple<IN1, IN2>> create(String expected,
-      Class<IN1> type1, Class<IN2> type2)
-  {
-    Function1<String, IN1> t1 = getTransformerForClass(type1);
-    Function1<String, IN2> t2 = getTransformerForClass(type2);
-    return create(expected, t1, t2);
-  }
+
   public static <IN1, IN2> ParseInputWith2Parameters<IN1, IN2, Tuple<IN1, IN2>> create(String expected,
       Function1<String, IN1> t1, Function1<String, IN2> t2)
   {
@@ -40,6 +32,6 @@ public static <IN1, IN2> ParseInputWith2Parameters<IN1, IN2, Tuple<IN1, IN2>> cr
   //    }
   public void verifyAll(Function1<OUT, Object> transform)
   {
-    ParseInput.from(expected, transformer).verifyAll(transform);
+    new ParseInput<OUT>(expected, s -> new Tuple<>(s, transformer.call(s))).verifyAll(transform);
   }
 }