StepHarness (and WithFile) now have a supportsRoundTrip method so we can start testing round trip serialization on steps.

Author: nedtwigg

testlib/src/main/java/com/diffplug/spotless/SerializableEqualityTester.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 DiffPlug
+ * Copyright 2016-2023 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -71,7 +71,7 @@ public void areDifferentThan() {
 	}
 
 	@SuppressWarnings("unchecked")
-	private static <T extends Serializable> T reserialize(T input) {
+	static <T extends Serializable> T reserialize(T input) {
 		byte[] asBytes = LazyForwardingEquality.toBytes(input);
 		ByteArrayInputStream byteInput = new ByteArrayInputStream(asBytes);
 		try (ObjectInputStream objectInput = new ObjectInputStream(byteInput)) {

testlib/src/main/java/com/diffplug/spotless/StepHarness.java

@@ -21,17 +21,14 @@
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Paths;
 import java.util.Arrays;
-import java.util.Objects;
 
 import org.assertj.core.api.AbstractStringAssert;
 import org.assertj.core.api.Assertions;
 
 /** An api for testing a {@code FormatterStep} that doesn't depend on the File path. DO NOT ADD FILE SUPPORT TO THIS, use {@link StepHarnessWithFile} if you need that. */
-public class StepHarness implements AutoCloseable {
-	private final Formatter formatter;
-
+public class StepHarness extends StepHarnessBase<StepHarness> {
 	private StepHarness(Formatter formatter) {
-		this.formatter = Objects.requireNonNull(formatter);
+		super(formatter);
 	}
 
 	/** Creates a harness for testing steps which don't depend on the file. */
@@ -57,14 +54,14 @@ public static StepHarness forFormatter(Formatter formatter) {
 
 	/** Asserts that the given element is transformed as expected, and that the result is idempotent. */
 	public StepHarness test(String before, String after) {
-		String actual = formatter.compute(LineEnding.toUnix(before), new File(""));
+		String actual = formatter().compute(LineEnding.toUnix(before), new File(""));
 		assertEquals(after, actual, "Step application failed");
 		return testUnaffected(after);
 	}
 
 	/** Asserts that the given element is idempotent w.r.t the step under test. */
 	public StepHarness testUnaffected(String idempotentElement) {
-		String actual = formatter.compute(LineEnding.toUnix(idempotentElement), new File(""));
+		String actual = formatter().compute(LineEnding.toUnix(idempotentElement), new File(""));
 		assertEquals(idempotentElement, actual, "Step is not idempotent");
 		return this;
 	}
@@ -88,7 +85,7 @@ public AbstractStringAssert<?> testResourceExceptionMsg(String resourceBefore) {
 
 	public AbstractStringAssert<?> testExceptionMsg(String before) {
 		try {
-			formatter.compute(LineEnding.toUnix(before), Formatter.NO_FILE_SENTINEL);
+			formatter().compute(LineEnding.toUnix(before), Formatter.NO_FILE_SENTINEL);
 			throw new SecurityException("Expected exception");
 		} catch (Throwable e) {
 			if (e instanceof SecurityException) {
@@ -105,9 +102,4 @@ public AbstractStringAssert<?> testExceptionMsg(String before) {
 			}
 		}
 	}
-
-	@Override
-	public void close() {
-		formatter.close();
-	}
 }

testlib/src/main/java/com/diffplug/spotless/StepHarnessBase.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2023 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless;
+
+import java.util.Objects;
+
+import org.assertj.core.api.Assertions;
+
+class StepHarnessBase<T extends StepHarnessBase<?>> implements AutoCloseable {
+	private final Formatter formatter;
+	private Formatter roundTripped;
+	private boolean supportsRoundTrip = false;
+
+	protected StepHarnessBase(Formatter formatter) {
+		this.formatter = Objects.requireNonNull(formatter);
+	}
+
+	public T supportsRoundTrip(boolean supportsRoundTrip) {
+		this.supportsRoundTrip = supportsRoundTrip;
+		return (T) this;
+	}
+
+	protected Formatter formatter() {
+		if (!supportsRoundTrip) {
+			return formatter;
+		} else {
+			if (roundTripped == null) {
+				roundTripped = SerializableEqualityTester.reserialize(formatter);
+				Assertions.assertThat(roundTripped).isEqualTo(formatter);
+			}
+			return roundTripped;
+		}
+	}
+
+	@Override
+	public void close() {
+		formatter.close();
+		if (roundTripped != null) {
+			roundTripped.close();
+		}
+	}
+}

testlib/src/main/java/com/diffplug/spotless/StepHarnessWithFile.java

@@ -26,13 +26,12 @@
 import org.assertj.core.api.Assertions;
 
 /** An api for testing a {@code FormatterStep} that depends on the File path. */
-public class StepHarnessWithFile implements AutoCloseable {
-	private final Formatter formatter;
+public class StepHarnessWithFile extends StepHarnessBase<StepHarnessWithFile> {
 	private final ResourceHarness harness;
 
 	private StepHarnessWithFile(ResourceHarness harness, Formatter formatter) {
+		super(formatter);
 		this.harness = Objects.requireNonNull(harness);
-		this.formatter = Objects.requireNonNull(formatter);
 	}
 
 	/** Creates a harness for testing steps which do depend on the file. */
@@ -54,14 +53,14 @@ public static StepHarnessWithFile forFormatter(ResourceHarness harness, Formatte
 
 	/** Asserts that the given element is transformed as expected, and that the result is idempotent. */
 	public StepHarnessWithFile test(File file, String before, String after) {
-		String actual = formatter.compute(LineEnding.toUnix(before), file);
+		String actual = formatter().compute(LineEnding.toUnix(before), file);
 		assertEquals(after, actual, "Step application failed");
 		return testUnaffected(file, after);
 	}
 
 	/** Asserts that the given element is idempotent w.r.t the step under test. */
 	public StepHarnessWithFile testUnaffected(File file, String idempotentElement) {
-		String actual = formatter.compute(LineEnding.toUnix(idempotentElement), file);
+		String actual = formatter().compute(LineEnding.toUnix(idempotentElement), file);
 		assertEquals(idempotentElement, actual, "Step is not idempotent");
 		return this;
 	}
@@ -96,7 +95,7 @@ public AbstractStringAssert<?> testResourceExceptionMsg(String filename, String
 
 	public AbstractStringAssert<?> testExceptionMsg(File file, String before) {
 		try {
-			formatter.compute(LineEnding.toUnix(before), file);
+			formatter().compute(LineEnding.toUnix(before), file);
 			throw new SecurityException("Expected exception");
 		} catch (Throwable e) {
 			if (e instanceof SecurityException) {
@@ -110,9 +109,4 @@ public AbstractStringAssert<?> testExceptionMsg(File file, String before) {
 			}
 		}
 	}
-
-	@Override
-	public void close() {
-		formatter.close();
-	}
 }