Adapt StepHarness for the new "exceptions never get thrown" environment.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2021 DiffPlug
+ * Copyright 2016-2022 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -54,7 +54,7 @@ protected File rootFolder() {
 	}
 
 	/** Returns a new child of the root folder. */
-	protected File newFile(String subpath) throws IOException {
+	protected File newFile(String subpath) {
 		return new File(rootFolder(), subpath);
 	}
 
@@ -85,12 +85,12 @@ protected void replace(String path, String toReplace, String replaceWith) throws
 	}
 
 	/** Returns the contents of the given file from the src/test/resources directory. */
-	protected static String getTestResource(String filename) throws IOException {
+	protected static String getTestResource(String filename) {
 		URL url = ResourceHarness.class.getResource("/" + filename);
 		if (url == null) {
 			throw new IllegalArgumentException("No such resource " + filename);
 		}
-		return Resources.toString(url, StandardCharsets.UTF_8);
+		return ThrowingEx.get(() -> Resources.toString(url, StandardCharsets.UTF_8));
 	}
 
 	/** Returns Files (in a temporary folder) which has the contents of the given file from the src/test/resources directory. */
@@ -176,7 +176,7 @@ public void matches(Consumer<AbstractCharSequenceAssert<?, String>> conditions)
 		}
 	}
 
-	protected WriteAsserter setFile(String path) throws IOException {
+	protected WriteAsserter setFile(String path) {
 		return new WriteAsserter(newFile(path));
 	}
 
@@ -188,21 +188,25 @@ private WriteAsserter(File file) {
 			this.file = file;
 		}
 
-		public File toLines(String... lines) throws IOException {
+		public File toLines(String... lines) {
 			return toContent(String.join("\n", Arrays.asList(lines)));
 		}
 
-		public File toContent(String content) throws IOException {
+		public File toContent(String content) {
 			return toContent(content, StandardCharsets.UTF_8);
 		}
 
-		public File toContent(String content, Charset charset) throws IOException {
-			Files.write(file.toPath(), content.getBytes(charset));
+		public File toContent(String content, Charset charset) {
+			ThrowingEx.run(() -> {
+				Files.write(file.toPath(), content.getBytes(charset));
+			});
 			return file;
 		}
 
-		public File toResource(String path) throws IOException {
-			Files.write(file.toPath(), getTestResource(path).getBytes(StandardCharsets.UTF_8));
+		public File toResource(String path) {
+			ThrowingEx.run(() -> {
+				Files.write(file.toPath(), getTestResource(path).getBytes(StandardCharsets.UTF_8));
+			});
 			return file;
 		}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2021 DiffPlug
+ * Copyright 2016-2022 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,34 +19,24 @@
 
 import java.io.File;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Objects;
-import java.util.function.Consumer;
 
-import org.assertj.core.api.AbstractThrowableAssert;
+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 FormatterFunc formatter;
+	private final Formatter formatter;
 
-	private StepHarness(FormatterFunc formatter) {
+	private StepHarness(Formatter formatter) {
 		this.formatter = Objects.requireNonNull(formatter);
 	}
 
 	/** Creates a harness for testing steps which don't depend on the file. */
 	public static StepHarness forStep(FormatterStep step) {
-		// We don't care if an individual FormatterStep is misbehaving on line-endings, because
-		// Formatter fixes that.  No reason to care in tests either.  It's likely to pop up when
-		// running tests on Windows from time-to-time
-		return new StepHarness(FormatterFunc.Closeable.ofDangerous(
-				() -> {
-					if (step instanceof FormatterStepImpl.Standard) {
-						((FormatterStepImpl.Standard<?>) step).cleanupFormatterFunc();
-					}
-				},
-				input -> LineEnding.toUnix(step.format(input, new File("")))));
+		return forSteps(step);
 	}
 
 	/** Creates a harness for testing steps which don't depend on the file. */
@@ -55,61 +45,67 @@ public static StepHarness forSteps(FormatterStep... steps) {
 				.steps(Arrays.asList(steps))
 				.lineEndingsPolicy(LineEnding.UNIX.createPolicy())
 				.encoding(StandardCharsets.UTF_8)
-				.rootDir(Paths.get(""))
 				.build());
 	}
 
 	/** Creates a harness for testing a formatter whose steps don't depend on the file. */
 	public static StepHarness forFormatter(Formatter formatter) {
-		return new StepHarness(FormatterFunc.Closeable.ofDangerous(
-				formatter::close,
-				input -> formatter.compute(input, new File(""))));
+		return new StepHarness(formatter);
 	}
 
 	/** Asserts that the given element is transformed as expected, and that the result is idempotent. */
-	public StepHarness test(String before, String after) throws Exception {
-		String actual = formatter.apply(before);
+	public StepHarness test(String before, String after) {
+		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) throws Exception {
-		String actual = formatter.apply(idempotentElement);
+	public StepHarness testUnaffected(String idempotentElement) {
+		String actual = formatter.compute(LineEnding.toUnix(idempotentElement), new File(""));
 		assertEquals(idempotentElement, actual, "Step is not idempotent");
 		return this;
 	}
 
 	/** Asserts that the given elements in  the resources directory are transformed as expected. */
-	public StepHarness testResource(String resourceBefore, String resourceAfter) throws Exception {
+	public StepHarness testResource(String resourceBefore, String resourceAfter) {
 		String before = ResourceHarness.getTestResource(resourceBefore);
 		String after = ResourceHarness.getTestResource(resourceAfter);
 		return test(before, after);
 	}
 
 	/** Asserts that the given elements in the resources directory are transformed as expected. */
-	public StepHarness testResourceUnaffected(String resourceIdempotent) throws Exception {
+	public StepHarness testResourceUnaffected(String resourceIdempotent) {
 		String idempotentElement = ResourceHarness.getTestResource(resourceIdempotent);
 		return testUnaffected(idempotentElement);
 	}
 
-	/** Asserts that the given elements in the resources directory are transformed as expected. */
-	public StepHarness testResourceException(String resourceBefore, Consumer<AbstractThrowableAssert<?, ? extends Throwable>> exceptionAssertion) throws Exception {
-		return testException(ResourceHarness.getTestResource(resourceBefore), exceptionAssertion);
+	public AbstractStringAssert<?> testResourceExceptionMsg(String resourceBefore) {
+		return testExceptionMsg(ResourceHarness.getTestResource(resourceBefore));
 	}
 
-	/** Asserts that the given elements in the resources directory are transformed as expected. */
-	public StepHarness testException(String before, Consumer<AbstractThrowableAssert<?, ? extends Throwable>> exceptionAssertion) throws Exception {
-		Throwable t = assertThrows(Throwable.class, () -> formatter.apply(before));
-		AbstractThrowableAssert<?, ? extends Throwable> abstractAssert = Assertions.assertThat(t);
-		exceptionAssertion.accept(abstractAssert);
-		return this;
+	public AbstractStringAssert<?> testExceptionMsg(String before) {
+		List<Lint> lints = formatter.lint(LineEnding.toUnix(before), FormatterStepImpl.SENTINEL);
+		if (lints.size() == 0) {
+			throw new AssertionError("No exception was thrown");
+		} else if (lints.size() >= 2) {
+			throw new AssertionError("Expected one lint, had " + lints.size());
+		} else {
+			return Assertions.assertThat(lints.get(0).getMsg());
+		}
+	}
+
+	public StepHarness assertZeroLints(String before) {
+		List<Lint> lints = formatter.lint(LineEnding.toUnix(before), FormatterStepImpl.SENTINEL);
+		if (lints.size() == 0) {
+			return this;
+		} else {
+			throw new AssertionError("Expected no lints, had " + lints);
+		}
 	}
 
 	@Override
 	public void close() {
-		if (formatter instanceof FormatterFunc.Closeable) {
-			((FormatterFunc.Closeable) formatter).close();
-		}
+		formatter.close();
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2021 DiffPlug
+ * Copyright 2016-2022 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,78 +18,91 @@
 import static org.junit.jupiter.api.Assertions.*;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Objects;
 
+import org.assertj.core.api.AbstractStringAssert;
+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 FormatterFunc formatter;
+	private final Formatter formatter;
+	private ResourceHarness harness;
 
-	private StepHarnessWithFile(FormatterFunc formatter) {
+	private StepHarnessWithFile(ResourceHarness harness, Formatter formatter) {
+		this.harness = Objects.requireNonNull(harness);
 		this.formatter = Objects.requireNonNull(formatter);
+
 	}
 
 	/** Creates a harness for testing steps which do depend on the file. */
-	public static StepHarnessWithFile forStep(FormatterStep step) {
-		// We don't care if an individual FormatterStep is misbehaving on line-endings, because
-		// Formatter fixes that.  No reason to care in tests either.  It's likely to pop up when
-		// running tests on Windows from time-to-time
-		return new StepHarnessWithFile(FormatterFunc.Closeable.ofDangerous(
-				() -> {
-					if (step instanceof FormatterStepImpl.Standard) {
-						((FormatterStepImpl.Standard<?>) step).cleanupFormatterFunc();
-					}
-				},
-				new FormatterFunc() {
-					@Override
-					public String apply(String unix) throws Exception {
-						return apply(unix, new File(""));
-					}
-
-					@Override
-					public String apply(String unix, File file) throws Exception {
-						return LineEnding.toUnix(step.format(unix, file));
-					}
-				}));
+	public static StepHarnessWithFile forStep(ResourceHarness harness, FormatterStep step) {
+		return new StepHarnessWithFile(harness, Formatter.builder()
+				.encoding(StandardCharsets.UTF_8)
+				.lineEndingsPolicy(LineEnding.UNIX.createPolicy())
+				.steps(Arrays.asList(step))
+				.build());
 	}
 
 	/** Creates a harness for testing a formatter whose steps do depend on the file. */
-	public static StepHarnessWithFile forFormatter(Formatter formatter) {
-		return new StepHarnessWithFile(FormatterFunc.Closeable.ofDangerous(
-				formatter::close,
-				input -> formatter.compute(input, new File(""))));
+	public static StepHarnessWithFile forFormatter(ResourceHarness harness, Formatter formatter) {
+		return new StepHarnessWithFile(harness, formatter);
 	}
 
 	/** Asserts that the given element is transformed as expected, and that the result is idempotent. */
-	public StepHarnessWithFile test(File file, String before, String after) throws Exception {
-		String actual = formatter.apply(before, file);
+	public StepHarnessWithFile test(File file, String before, String after) {
+		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) throws Exception {
-		String actual = formatter.apply(idempotentElement, file);
+	public StepHarnessWithFile testUnaffected(File file, String idempotentElement) {
+		String actual = formatter.compute(LineEnding.toUnix(idempotentElement), file);
 		assertEquals(idempotentElement, actual, "Step is not idempotent");
 		return this;
 	}
 
 	/** Asserts that the given elements in  the resources directory are transformed as expected. */
-	public StepHarnessWithFile testResource(File file, String resourceBefore, String resourceAfter) throws Exception {
-		String before = ResourceHarness.getTestResource(resourceBefore);
-		String after = ResourceHarness.getTestResource(resourceAfter);
-		return test(file, before, after);
+	public StepHarnessWithFile testResource(String resourceBefore, String resourceAfter) {
+		return testResource(resourceBefore, resourceBefore, resourceAfter);
+	}
+
+	public StepHarnessWithFile testResource(String filename, String resourceBefore, String resourceAfter) {
+		String contentBefore = ResourceHarness.getTestResource(resourceBefore);
+		File file = harness.setFile(filename).toContent(contentBefore);
+		return test(file, contentBefore, ResourceHarness.getTestResource(resourceAfter));
 	}
 
 	/** Asserts that the given elements in the resources directory are transformed as expected. */
-	public StepHarnessWithFile testResourceUnaffected(File file, String resourceIdempotent) throws Exception {
-		String idempotentElement = ResourceHarness.getTestResource(resourceIdempotent);
-		return testUnaffected(file, idempotentElement);
+	public StepHarnessWithFile testResourceUnaffected(String resourceIdempotent) {
+		String contentBefore = ResourceHarness.getTestResource(resourceIdempotent);
+		File file = harness.setFile(resourceIdempotent).toContent(contentBefore);
+		return testUnaffected(file, contentBefore);
+	}
+
+	public AbstractStringAssert<?> testResourceExceptionMsg(String resourceBefore) throws IOException {
+		String contentBefore = ResourceHarness.getTestResource(resourceBefore);
+		File file = harness.setFile(resourceBefore).toContent(contentBefore);
+		return testExceptionMsg(file, contentBefore);
+	}
+
+	public AbstractStringAssert<?> testExceptionMsg(File file, String before) {
+		List<Lint> lints = formatter.lint(LineEnding.toUnix(before), file);
+		if (lints.size() == 0) {
+			throw new AssertionError("No exception was thrown");
+		} else if (lints.size() >= 2) {
+			throw new AssertionError("Expected one lint, had " + lints.size());
+		} else {
+			return Assertions.assertThat(lints.get(0).getMsg());
+		}
 	}
 
 	@Override
 	public void close() {
-		if (formatter instanceof FormatterFunc.Closeable) {
-			((FormatterFunc.Closeable) formatter).close();
-		}
+		formatter.close();
 	}
 }

testlib/src/test/java/com/diffplug/spotless/FormatterTest.java

@@ -17,14 +17,11 @@
 
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 
 import org.junit.jupiter.api.Test;
 
-import com.diffplug.common.base.StandardSystemProperty;
 import com.diffplug.spotless.generic.EndWithNewlineStep;
 
 class FormatterTest {
@@ -34,7 +31,6 @@ void equality() {
 		new SerializableEqualityTester() {
 			private LineEnding.Policy lineEndingsPolicy = LineEnding.UNIX.createPolicy();
 			private Charset encoding = StandardCharsets.UTF_8;
-			private Path rootDir = Paths.get(StandardSystemProperty.USER_DIR.value());
 			private List<FormatterStep> steps = new ArrayList<>();
 
 			@Override
@@ -47,9 +43,6 @@ protected void setupTest(API api) throws Exception {
 				encoding = StandardCharsets.UTF_16;
 				api.areDifferentThan();
 
-				rootDir = rootDir.getParent();
-				api.areDifferentThan();
-
 				steps.add(EndWithNewlineStep.create());
 				api.areDifferentThan();
 			}