From 4bfd0d122cf44bf51220fb6cbf86d855247a0068 Mon Sep 17 00:00:00 2001
From: Lukas Krecan <lukas@krecan.net>
Date: Wed, 1 Nov 2023 20:36:59 +0100
Subject: [PATCH] Ass spotless

---
 .../jsonunit/assertj/ExpectedNode.java        |    7 +-
 .../jsonunit/assertj/JsonAssert.java          |   68 +-
 .../jsonunit/assertj/JsonAssertions.java      |   10 +-
 .../jsonunit/assertj/JsonComparator.java      |   18 +-
 .../assertj/JsonComparisonStrategy.java       |    3 +-
 .../jsonunit/assertj/JsonListAssert.java      |   23 +-
 .../jsonunit/assertj/JsonMapAssert.java       |   37 +-
 .../assertj/internal/JsonRepresentation.java  |    3 +-
 .../jsonunit/core/Configuration.java          |  143 +-
 .../jsonunit/core/ConfigurationWhen.java      |    8 +-
 .../javacrumbs/jsonunit/core/Matchers.java    |    9 +-
 .../jsonunit/core/NumberComparator.java       |    3 +-
 .../net/javacrumbs/jsonunit/core/Option.java  |    1 -
 .../core/internal/AbstractNodeFactory.java    |   14 +-
 .../core/internal/ArrayComparison.java        |   18 +-
 .../jsonunit/core/internal/ArrayUtils.java    |    4 +-
 .../core/internal/ComparisonMatrix.java       |   77 +-
 .../jsonunit/core/internal/Context.java       |   25 +-
 .../jsonunit/core/internal/Converter.java     |   28 +-
 .../internal/DefaultNumberComparator.java     |    6 +-
 .../jsonunit/core/internal/Diff.java          |  244 ++-
 .../core/internal/DifferenceContextImpl.java  |    4 +-
 .../core/internal/DifferenceImpl.java         |    3 +-
 .../jsonunit/core/internal/Differences.java   |    3 +-
 .../core/internal/ExceptionFactory.java       |   27 +-
 .../core/internal/ExceptionUtils.java         |   11 +-
 .../core/internal/GenericNodeBuilder.java     |   21 +-
 .../core/internal/GsonNodeFactory.java        |    8 +-
 .../core/internal/HamcrestHandler.java        |   21 +-
 .../core/internal/Jackson2NodeFactory.java    |   10 +-
 .../core/internal/JohnzonNodeFactory.java     |   44 +-
 .../core/internal/JsonOrgNodeFactory.java     |   14 +-
 .../jsonunit/core/internal/JsonSource.java    |    2 -
 .../jsonunit/core/internal/JsonUtils.java     |   43 +-
 .../core/internal/MoshiNodeFactory.java       |    7 +-
 .../jsonunit/core/internal/Node.java          |    6 +-
 .../jsonunit/core/internal/NodeWrapper.java   |    4 +-
 .../jsonunit/core/internal/Path.java          |    8 +-
 .../jsonunit/core/internal/PathMatcher.java   |   15 +-
 .../jsonunit/core/internal/PathOption.java    |    4 +-
 .../core/internal/PathOptionMatcher.java      |    6 +-
 .../jsonunit/core/internal/Utils.java         |    3 +-
 .../internal/matchers/InternalMatcher.java    |   62 +-
 .../jsonunit/core/listener/Difference.java    |    7 +-
 .../core/listener/DifferenceContext.java      |    1 -
 .../core/listener/DifferenceListener.java     |    1 -
 .../jsonunit/core/util/ResourceUtils.java     |    6 +-
 .../jsonunit/core/internal/ConverterTest.java |   22 +-
 .../core/internal/DifferenceTest.java         |   42 +-
 .../jsonunit/core/internal/JsonUtilsTest.java |   20 +-
 .../core/internal/NodeFactoryTest.java        |   27 +-
 .../core/internal/PathMatcherTest.java        |    3 +-
 .../jsonunit/fluent/JsonFluentAssert.java     |   19 +-
 .../jsonpath/InternalJsonPathUtils.java       |   62 +-
 .../jsonunit/jsonpath/JsonPathAdapter.java    |   19 +-
 .../jsonpath/InternalJsonPathUtilsTest.java   |    8 +-
 .../spring/AbstractSpringMatcher.java         |    8 +-
 .../spring/AbstractSpringMatchers.java        |   11 +-
 .../spring/JsonUnitRequestMatchers.java       |   10 +-
 .../spring/JsonUnitResultMatchers.java        |   16 +-
 .../net/javacrumbs/jsonunit/spring/Utils.java |    7 +-
 .../spring/WebTestClientJsonMatcher.java      |   20 +-
 .../jsonunit/spring/testit/ClientTest.java    |   46 +-
 .../jsonunit/spring/testit/MockMvcTest.java   |   89 +-
 .../spring/testit/WebTestClientTest.java      |  119 +-
 .../spring/testit/demo/ExampleController.java |   21 +-
 .../spring/testit/demo/SpringConfig.java      |    4 +-
 .../jsonunit/ConfigurableJsonMatcher.java     |    7 +-
 .../net/javacrumbs/jsonunit/JsonAssert.java   |   18 +-
 .../net/javacrumbs/jsonunit/JsonMatchers.java |   44 +-
 pom.xml                                       |   11 +
 .../test/base/AbstractAssertJTest.java        | 1334 ++++++++++-------
 .../test/base/AbstractJsonAssertTest.java     |  690 +++++----
 .../base/AbstractJsonFluentAssertTest.java    |  462 +++---
 .../test/base/AbstractJsonMatchersTest.java   |  129 +-
 .../jsonunit/test/base/JsonTestUtils.java     |   13 +-
 .../base/RecordingDifferenceListener.java     |    5 +-
 .../jsonunit/test/base/RegexBuilder.java      |    1 -
 .../test/base/beans/Jackson2Bean.java         |    2 +-
 .../beans/Jackson2IgnorePropertyBean.java     |    1 -
 .../jsonunit/test/all/AllAssertJTest.java     |   74 +-
 .../jsonunit/test/all/AllJsonAssertTest.java  |   66 +-
 .../test/all/AllJsonFluentAssertTest.java     |    8 +-
 .../test/all/AllJsonMatchersTest.java         |   16 +-
 .../jsonunit/test/gson/GsonAssertJTest.java   |    2 +-
 .../test/gson/GsonJsonAssertTest.java         |    1 -
 .../test/gson/GsonJsonFluentAssertTest.java   |    4 +-
 .../jackson2config/Jackson2ConfigTest.java    |    7 +-
 .../Java8ObjectMapperProvider.java            |    1 -
 .../test/jackson2/Jackson2AssertJTest.java    |   20 +-
 .../jackson2/Jackson2FluentAssertTest.java    |    4 +-
 .../test/johnzon/JohnzonAssertJTest.java      |    8 +-
 .../test/johnzon/JohnzonJsonAssertTest.java   |    1 -
 .../johnzon/JohnzonJsonFluentAssertTest.java  |   17 +-
 .../jsonunit/test/jsonpath/JsonPathTest.java  |   39 +-
 .../test/jsonorg/JsonOrgAssertJTest.java      |    6 +-
 .../test/jsonorg/JsonOrgJsonAssertTest.java   |   12 +-
 .../jsonorg/JsonOrgJsonFluentAssertTest.java  |    4 +-
 .../jsonunit/test/junit4/JUnit4Test.java      |   19 +-
 .../jsonunit/test/moshi/MoshiAssertJTest.java |   10 +-
 .../test/moshi/MoshiFluentAssertTest.java     |    4 +-
 .../test/nohamcrest/NoHamcrestTest.java       |    6 +-
 102 files changed, 2734 insertions(+), 1975 deletions(-)

diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/ExpectedNode.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/ExpectedNode.java
index ee6ec8134..ac4a09242 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/ExpectedNode.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/ExpectedNode.java
@@ -15,11 +15,9 @@
  */
 package net.javacrumbs.jsonunit.assertj;
 
-
-import net.javacrumbs.jsonunit.core.internal.Node;
-
 import java.math.BigDecimal;
 import java.util.Iterator;
+import net.javacrumbs.jsonunit.core.internal.Node;
 
 /**
  * In AssertJ we need to know which node is expected and which is actual. This class marks expected node.
@@ -93,8 +91,7 @@ public Object getValue() {
     }
 
     @Override
-    public void ___do_not_implement_this_interface_seriously() {
-    }
+    public void ___do_not_implement_this_interface_seriously() {}
 
     @Override
     public String toString() {
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssert.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssert.java
index d44caaffb..f45c143ba 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssert.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssert.java
@@ -15,6 +15,26 @@
  */
 package net.javacrumbs.jsonunit.assertj;
 
+import static net.javacrumbs.jsonunit.core.internal.Diff.quoteTextValue;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getNode;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
+import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.ARRAY;
+import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.BOOLEAN;
+import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.NULL;
+import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.NUMBER;
+import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.OBJECT;
+import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.STRING;
+import static net.javacrumbs.jsonunit.jsonpath.InternalJsonPathUtils.resolveJsonPaths;
+import static org.assertj.core.description.Description.mostRelevantDescription;
+import static org.assertj.core.util.Strings.isNullOrEmpty;
+
+import java.math.BigDecimal;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
@@ -39,34 +59,15 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.math.BigDecimal;
-import java.net.URI;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-
-import static net.javacrumbs.jsonunit.core.internal.Diff.quoteTextValue;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getNode;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
-import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.ARRAY;
-import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.BOOLEAN;
-import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.NULL;
-import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.NUMBER;
-import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.OBJECT;
-import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.STRING;
-import static net.javacrumbs.jsonunit.jsonpath.InternalJsonPathUtils.resolveJsonPaths;
-import static org.assertj.core.description.Description.mostRelevantDescription;
-import static org.assertj.core.util.Strings.isNullOrEmpty;
-
 public class JsonAssert extends AbstractAssert<JsonAssert, Object> {
     final Path path;
     final Configuration configuration;
     private final Object actualForMatcher;
 
     JsonAssert(Path path, Configuration configuration, Object actual, boolean alreadyParsed) {
-        super(alreadyParsed ? JsonUtils.wrapDeserializedObject(actual) : JsonUtils.convertToJson(actual, "actual"), JsonAssert.class);
+        super(
+                alreadyParsed ? JsonUtils.wrapDeserializedObject(actual) : JsonUtils.convertToJson(actual, "actual"),
+                JsonAssert.class);
         this.path = path;
         this.configuration = configuration;
         this.actualForMatcher = alreadyParsed ? JsonUtils.wrapDeserializedObject(actual) : actual;
@@ -89,7 +90,6 @@ public JsonAssert node(@NotNull String node) {
         return new JsonAssert(path.to(node), configuration, getNode(actual, node));
     }
 
-
     /**
      * Allows to do multiple comparisons on a document like
      *
@@ -133,7 +133,7 @@ public JsonAssert isEqualTo(@Nullable Object expected) {
     public JsonMapAssert isObject() {
         Node node = assertType(OBJECT);
         return new JsonMapAssert((Map<String, Object>) node.getValue(), path.asPrefix(), configuration)
-            .as("Different value found in node \"%s\"", path);
+                .as("Different value found in node \"%s\"", path);
     }
 
     /**
@@ -151,7 +151,7 @@ public BigDecimalAssert isNumber() {
     public BigIntegerAssert isIntegralNumber() {
         Node node = internalMatcher().assertIntegralNumber();
         return new BigIntegerAssert(node.decimalValue().toBigIntegerExact())
-            .as("Different value found in node \"%s\"", path);
+                .as("Different value found in node \"%s\"", path);
     }
 
     /**
@@ -167,7 +167,8 @@ public BigDecimalAssert asNumber() {
             try {
                 return createBigDecimalAssert(new BigDecimal(node.asText()));
             } catch (NumberFormatException e) {
-                failWithMessage("Node \"" + path + "\" can not be converted to number expected: <a number> but was: <" + quoteTextValue(node.getValue()) + ">.");
+                failWithMessage("Node \"" + path + "\" can not be converted to number expected: <a number> but was: <"
+                        + quoteTextValue(node.getValue()) + ">.");
             }
         } else {
             internalMatcher().failOnType(node, "number or string");
@@ -182,13 +183,7 @@ private BigDecimalAssert createBigDecimalAssert(BigDecimal value) {
 
     private InternalMatcher internalMatcher() {
         String description = mostRelevantDescription(info.description(), "Node \"" + path + "\"");
-        return new InternalMatcher(
-            actualForMatcher,
-            path.asPrefix(),
-            "",
-            configuration,
-            description
-        );
+        return new InternalMatcher(actualForMatcher, path.asPrefix(), "", configuration, description);
     }
 
     /**
@@ -199,8 +194,7 @@ private InternalMatcher internalMatcher() {
     @NotNull
     public JsonListAssert isArray() {
         Node node = assertType(ARRAY);
-        return new JsonListAssert((List<?>)node.getValue(), path.asPrefix(), configuration)
-            .as( "Node \"%s\"", path);
+        return new JsonListAssert((List<?>) node.getValue(), path.asPrefix(), configuration).as("Node \"%s\"", path);
     }
 
     /**
@@ -345,7 +339,8 @@ public ConfigurableJsonAssert withOptions(@NotNull Collection<Option> optionsToA
          * </code>
          */
         @NotNull
-        public ConfigurableJsonAssert withConfiguration(@NotNull Function<Configuration, Configuration> configurationFunction) {
+        public ConfigurableJsonAssert withConfiguration(
+                @NotNull Function<Configuration, Configuration> configurationFunction) {
             Configuration newConfiguration = configurationFunction.apply(configuration);
             newConfiguration = resolveJsonPaths(originalActual, newConfiguration);
             return new ConfigurableJsonAssert(path, newConfiguration, actual);
@@ -408,7 +403,6 @@ public ConfigurableJsonAssert withMatcher(@NotNull String matcherName, @NotNull
             return withConfiguration(c -> c.withMatcher(matcherName, matcher));
         }
 
-
         /**
          * Sets difference listener
          */
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssertions.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssertions.java
index 2fee3c6a6..0969b54c0 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssertions.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonAssertions.java
@@ -29,9 +29,7 @@ public final class JsonAssertions {
         Assertions.useRepresentation(new JsonRepresentation());
     }
 
-    private JsonAssertions() {
-
-    }
+    private JsonAssertions() {}
 
     @NotNull
     public static ConfigurableJsonAssert assertThatJson(@Nullable Object actual) {
@@ -49,9 +47,10 @@ public static ConfigurableJsonAssert assertThatJson(@Nullable Object actual) {
      * }</pre>
      */
     @NotNull
-    public static ConfigurableJsonAssert assertThatJson(@NotNull Object actual, @NotNull JsonAssertionCallback... callbacks) {
+    public static ConfigurableJsonAssert assertThatJson(
+            @NotNull Object actual, @NotNull JsonAssertionCallback... callbacks) {
         ConfigurableJsonAssert a = assertThatJson(actual);
-        for (JsonAssertionCallback callback: callbacks) {
+        for (JsonAssertionCallback callback : callbacks) {
             callback.doAssert(a);
         }
         return a;
@@ -68,7 +67,6 @@ public static Object json(Object input) {
         return new ExpectedNode(JsonUtils.convertToJson(input, "expected", true));
     }
 
-
     /**
      * Value passed here is not parsed as JSON but used as it is
      */
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparator.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparator.java
index 4a2180060..1464cb6d5 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparator.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparator.java
@@ -15,17 +15,16 @@
  */
 package net.javacrumbs.jsonunit.assertj;
 
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.wrapDeserializedObject;
+
+import java.util.Comparator;
+import java.util.List;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.Diff;
 import net.javacrumbs.jsonunit.core.internal.Node;
 import net.javacrumbs.jsonunit.core.internal.Path;
 import org.assertj.core.groups.Tuple;
 
-import java.util.Comparator;
-import java.util.List;
-
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.wrapDeserializedObject;
-
 class JsonComparator implements Comparator<Object> {
     private final Configuration configuration;
     private final Path path;
@@ -44,10 +43,11 @@ public int compare(Object actual, Object expected) {
         }
 
         // this comparator is not transitive, `expected` is usually a Node and `actual` is usually a Map, or primitive
-        if (
-            (actualParsed && !(actual instanceof Node) && (expected instanceof Node) && !(expected instanceof ExpectedNode)) ||
-            (actual instanceof ExpectedNode)
-        ) {
+        if ((actualParsed
+                        && !(actual instanceof Node)
+                        && (expected instanceof Node)
+                        && !(expected instanceof ExpectedNode))
+                || (actual instanceof ExpectedNode)) {
             Object tmp = actual;
             actual = expected;
             expected = tmp;
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparisonStrategy.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparisonStrategy.java
index 4ec10e738..58cc46061 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparisonStrategy.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonComparisonStrategy.java
@@ -15,11 +15,10 @@
  */
 package net.javacrumbs.jsonunit.assertj;
 
+import java.util.Set;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.Option;
 
-import java.util.Set;
-
 class JsonComparisonStrategy {
     private final Configuration configuration;
 
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonListAssert.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonListAssert.java
index fd41474ef..61ab66617 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonListAssert.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonListAssert.java
@@ -15,6 +15,10 @@
  */
 package net.javacrumbs.jsonunit.assertj;
 
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.wrapDeserializedObject;
+import static org.assertj.core.util.Lists.newArrayList;
+
+import java.util.List;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.Diff;
 import net.javacrumbs.jsonunit.core.internal.Path;
@@ -25,11 +29,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.wrapDeserializedObject;
-import static org.assertj.core.util.Lists.newArrayList;
-
 public class JsonListAssert extends FactoryBasedNavigableListAssert<JsonListAssert, List<?>, Object, JsonAssert> {
     private final Configuration configuration;
     private final Path path;
@@ -57,7 +56,8 @@ public JsonListAssert isNotEqualTo(@Nullable Object other) {
         Diff diff = createDiff(other);
         if (diff.similar()) {
             JsonComparisonStrategy strategy = new JsonComparisonStrategy(configuration);
-            throwAssertionError(new BasicErrorMessageFactory("%nExpecting:%n <%s>%nnot to be equal to:%n <%s>%n%s", actual, other, strategy));
+            throwAssertionError(new BasicErrorMessageFactory(
+                    "%nExpecting:%n <%s>%nnot to be equal to:%n <%s>%n%s", actual, other, strategy));
         }
         return this;
     }
@@ -72,7 +72,8 @@ protected JsonListAssert newAbstractIterableAssert(Iterable<?> iterable) {
      */
     @Override
     @Deprecated
-    public <ASSERT extends AbstractAssert<?, ?>> ASSERT element(int index, InstanceOfAssertFactory<?, ASSERT> assertFactory) {
+    public <ASSERT extends AbstractAssert<?, ?>> ASSERT element(
+            int index, InstanceOfAssertFactory<?, ASSERT> assertFactory) {
         return super.element(index, assertFactory);
     }
 
@@ -81,14 +82,16 @@ protected JsonListAssert newAbstractIterableAssert(Iterable<?> iterable) {
      */
     @Override
     @Deprecated
-    public <ASSERT extends AbstractAssert<?, ?>> ASSERT singleElement(InstanceOfAssertFactory<?, ASSERT> assertFactory) {
+    public <ASSERT extends AbstractAssert<?, ?>> ASSERT singleElement(
+            InstanceOfAssertFactory<?, ASSERT> assertFactory) {
         return super.singleElement(assertFactory);
     }
 
     @Override
-    public <ASSERT extends AbstractAssert<?, ?>> ASSERT asInstanceOf(InstanceOfAssertFactory<?, ASSERT> instanceOfAssertFactory) {
+    public <ASSERT extends AbstractAssert<?, ?>> ASSERT asInstanceOf(
+            InstanceOfAssertFactory<?, ASSERT> instanceOfAssertFactory) {
         throw failure("Please use isString(), isNumber(), isBoolean(), isNull(), isUri(), isArray() or isObject().%n"
-            + "This method will most likely not provide the result you expect it to.");
+                + "This method will most likely not provide the result you expect it to.");
     }
 
     /**
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonMapAssert.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonMapAssert.java
index 2f5b0524f..e17824d00 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonMapAssert.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/JsonMapAssert.java
@@ -15,19 +15,6 @@
  */
 package net.javacrumbs.jsonunit.assertj;
 
-import net.javacrumbs.jsonunit.core.Configuration;
-import net.javacrumbs.jsonunit.core.internal.Diff;
-import net.javacrumbs.jsonunit.core.internal.Node;
-import net.javacrumbs.jsonunit.core.internal.Path;
-import org.assertj.core.api.AbstractMapAssert;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.stream.Collectors;
-
 import static java.util.Arrays.stream;
 import static java.util.Objects.deepEquals;
 import static java.util.stream.Collectors.toList;
@@ -41,6 +28,18 @@
 import static org.assertj.core.error.ShouldNotContainValue.shouldNotContainValue;
 import static org.assertj.core.util.Arrays.array;
 
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import net.javacrumbs.jsonunit.core.Configuration;
+import net.javacrumbs.jsonunit.core.internal.Diff;
+import net.javacrumbs.jsonunit.core.internal.Node;
+import net.javacrumbs.jsonunit.core.internal.Path;
+import org.assertj.core.api.AbstractMapAssert;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
 public class JsonMapAssert extends AbstractMapAssert<JsonMapAssert, Map<String, Object>, String, Object> {
     private final Configuration configuration;
     private final Path path;
@@ -95,14 +94,16 @@ public JsonMapAssert doesNotContainValue(@Nullable Object expected) {
     @Override
     @NotNull
     @Deprecated
-    public JsonMapAssert isEqualToIgnoringGivenFields(@Nullable Object other, @NotNull String... propertiesOrFieldsToIgnore) {
+    public JsonMapAssert isEqualToIgnoringGivenFields(
+            @Nullable Object other, @NotNull String... propertiesOrFieldsToIgnore) {
         return compare(other, configuration.whenIgnoringPaths(propertiesOrFieldsToIgnore));
     }
 
     @Override
     @NotNull
     @Deprecated
-    public JsonMapAssert isEqualToComparingOnlyGivenFields(@Nullable Object other, @NotNull String... propertiesOrFieldsUsedInComparison) {
+    public JsonMapAssert isEqualToComparingOnlyGivenFields(
+            @Nullable Object other, @NotNull String... propertiesOrFieldsUsedInComparison) {
         throw unsupportedOperation();
     }
 
@@ -169,7 +170,8 @@ public JsonMapAssert containsExactlyEntriesOf(Map<? extends String, ?> map) {
     @SafeVarargs
     @Override
     protected final JsonMapAssert containsOnlyForProxy(Entry<? extends String, ?>... expected) {
-        Map<? extends String, ?> expectedAsMap = stream(expected).collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+        Map<? extends String, ?> expectedAsMap =
+                stream(expected).collect(Collectors.toMap(Entry::getKey, Entry::getValue));
         return isEqualTo(wrapDeserializedObject(expectedAsMap));
     }
 
@@ -290,6 +292,7 @@ private boolean contains(Object expected) {
     }
 
     private boolean isSimilar(Object actual, Object expected) {
-        return Diff.create(expected, actual, "fullJson", path.asPrefix(), configuration).similar();
+        return Diff.create(expected, actual, "fullJson", path.asPrefix(), configuration)
+                .similar();
     }
 }
diff --git a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/internal/JsonRepresentation.java b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/internal/JsonRepresentation.java
index cd3f82354..558c6db95 100644
--- a/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/internal/JsonRepresentation.java
+++ b/json-unit-assertj/src/main/java/net/javacrumbs/jsonunit/assertj/internal/JsonRepresentation.java
@@ -15,11 +15,10 @@
  */
 package net.javacrumbs.jsonunit.assertj.internal;
 
+import java.util.Map;
 import net.javacrumbs.jsonunit.core.internal.Node;
 import org.assertj.core.presentation.StandardRepresentation;
 
-import java.util.Map;
-
 public class JsonRepresentation extends StandardRepresentation {
     @Override
     protected String toStringOf(Map<?, ?> map) {
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Configuration.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Configuration.java
index dfd0e3d14..c66aeb270 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Configuration.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Configuration.java
@@ -15,6 +15,14 @@
  */
 package net.javacrumbs.jsonunit.core;
 
+import static java.util.Arrays.asList;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
 import net.javacrumbs.jsonunit.core.internal.DefaultNumberComparator;
@@ -24,15 +32,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-
-import static java.util.Arrays.asList;
-
 /**
  * Comparison configuration. Immutable.
  */
@@ -42,7 +41,15 @@ public class Configuration {
     private static final String DEFAULT_IGNORE_PLACEHOLDER = "${json-unit.ignore}";
     private static final String ALTERNATIVE_IGNORE_PLACEHOLDER = "#{json-unit.ignore}";
     private static final DefaultNumberComparator DEFAULT_NUMBER_COMPARATOR = new DefaultNumberComparator();
-    private static final Configuration EMPTY_CONFIGURATION = new Configuration(null, Options.empty(), DEFAULT_IGNORE_PLACEHOLDER, Matchers.empty(), Collections.emptySet(), DUMMY_LISTENER, Collections.emptyList(), DEFAULT_NUMBER_COMPARATOR);
+    private static final Configuration EMPTY_CONFIGURATION = new Configuration(
+            null,
+            Options.empty(),
+            DEFAULT_IGNORE_PLACEHOLDER,
+            Matchers.empty(),
+            Collections.emptySet(),
+            DUMMY_LISTENER,
+            Collections.emptyList(),
+            DEFAULT_NUMBER_COMPARATOR);
     private final BigDecimal tolerance;
     private final Options options;
     private final String ignorePlaceholder;
@@ -52,7 +59,15 @@ public class Configuration {
     private final DifferenceListener differenceListener;
     private final NumberComparator numberComparator;
 
-    private Configuration(@Nullable BigDecimal tolerance, Options options, String ignorePlaceholder, Matchers matchers, Set<String> pathsToBeIgnored, DifferenceListener differenceListener, List<PathOption> pathOptions, NumberComparator numberComparator) {
+    private Configuration(
+            @Nullable BigDecimal tolerance,
+            Options options,
+            String ignorePlaceholder,
+            Matchers matchers,
+            Set<String> pathsToBeIgnored,
+            DifferenceListener differenceListener,
+            List<PathOption> pathOptions,
+            NumberComparator numberComparator) {
         this.tolerance = tolerance;
         this.options = options;
         this.ignorePlaceholder = ignorePlaceholder;
@@ -79,7 +94,15 @@ public static Configuration empty() {
      */
     @NotNull
     public Configuration withTolerance(@Nullable BigDecimal tolerance) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -114,7 +137,15 @@ public Configuration when(@NotNull Option first, @NotNull Option... next) {
      */
     @NotNull
     public Configuration withOptions(@NotNull Option first, @NotNull Option... next) {
-        return new Configuration(tolerance, options.with(first, next), ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options.with(first, next),
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -122,12 +153,28 @@ public Configuration withOptions(@NotNull Option first, @NotNull Option... next)
      */
     @NotNull
     public Configuration withOptions(@NotNull Collection<Option> optionsToAdd) {
-        return new Configuration(tolerance, options.with(optionsToAdd), ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options.with(optionsToAdd),
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     @NotNull
     public Configuration resetOptions() {
-        return new Configuration(tolerance, Options.empty(), ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                Options.empty(),
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -156,12 +203,28 @@ Configuration addPathOption(@NotNull PathOption pathOption) {
 
     @NotNull
     public Configuration withPathOptions(@NotNull List<PathOption> pathOptions) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, List.copyOf(pathOptions), numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                List.copyOf(pathOptions),
+                numberComparator);
     }
 
     @NotNull
     public Configuration whenIgnoringPaths(@NotNull Collection<String> pathsToBeIgnored) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers, Set.copyOf(pathsToBeIgnored), differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers,
+                Set.copyOf(pathsToBeIgnored),
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -186,7 +249,15 @@ public Configuration whenIgnoringPaths(@NotNull String... pathsToBeIgnored) {
      */
     @NotNull
     public Configuration withIgnorePlaceholder(@NotNull String ignorePlaceholder) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -198,7 +269,15 @@ public Configuration withIgnorePlaceholder(@NotNull String ignorePlaceholder) {
      */
     @NotNull
     public Configuration withMatcher(@NotNull String matcherName, @NotNull Matcher<?> matcher) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers.with(matcherName, matcher), pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers.with(matcherName, matcher),
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -206,7 +285,15 @@ public Configuration withMatcher(@NotNull String matcherName, @NotNull Matcher<?
      */
     @NotNull
     public Configuration withDifferenceListener(@NotNull DifferenceListener differenceListener) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     /**
@@ -214,7 +301,15 @@ public Configuration withDifferenceListener(@NotNull DifferenceListener differen
      */
     @NotNull
     public Configuration withNumberComparator(@NotNull NumberComparator numberComparator) {
-        return new Configuration(tolerance, options, ignorePlaceholder, matchers, pathsToBeIgnored, differenceListener, pathOptions, numberComparator);
+        return new Configuration(
+                tolerance,
+                options,
+                ignorePlaceholder,
+                matchers,
+                pathsToBeIgnored,
+                differenceListener,
+                pathOptions,
+                numberComparator);
     }
 
     @NotNull
@@ -264,9 +359,11 @@ public NumberComparator getNumberComparator() {
 
     public boolean shouldIgnore(String expectedValue) {
         if (DEFAULT_IGNORE_PLACEHOLDER.equals(ignorePlaceholder)) {
-            // special handling of default state. We want to support both # and $ before {json-unit.ignore} but do not want to
+            // special handling of default state. We want to support both # and $ before {json-unit.ignore} but do not
+            // want to
             // override user specified value if any
-            return DEFAULT_IGNORE_PLACEHOLDER.equals(expectedValue) || ALTERNATIVE_IGNORE_PLACEHOLDER.equals(expectedValue);
+            return DEFAULT_IGNORE_PLACEHOLDER.equals(expectedValue)
+                    || ALTERNATIVE_IGNORE_PLACEHOLDER.equals(expectedValue);
         } else {
             return ignorePlaceholder.equals(expectedValue);
         }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/ConfigurationWhen.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/ConfigurationWhen.java
index dc8fa7d7c..7481e90d1 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/ConfigurationWhen.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/ConfigurationWhen.java
@@ -1,14 +1,13 @@
 package net.javacrumbs.jsonunit.core;
 
-import net.javacrumbs.jsonunit.core.internal.PathOption;
-import org.jetbrains.annotations.NotNull;
-
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import net.javacrumbs.jsonunit.core.internal.PathOption;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * Everything for {@link Configuration#when(PathsParam, ApplicableForPath...)}
@@ -113,8 +112,7 @@ public Configuration applyForPaths(@NotNull Configuration configuration, @NotNul
     }
 
     static class IgnoredParam implements ApplicableForPath {
-        private IgnoredParam() {
-        }
+        private IgnoredParam() {}
 
         @Override
         @NotNull
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Matchers.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Matchers.java
index b16956c22..35437d480 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Matchers.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Matchers.java
@@ -15,14 +15,12 @@
  */
 package net.javacrumbs.jsonunit.core;
 
-import org.hamcrest.Matcher;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
-
+import org.hamcrest.Matcher;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Immutable map of matchers.
@@ -36,7 +34,6 @@ private Matchers(Map<String, Matcher<?>> matcherMap) {
         this.matcherMap = matcherMap;
     }
 
-
     static Matchers empty() {
         return EMPTY;
     }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/NumberComparator.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/NumberComparator.java
index d0d9c0d55..2543423ab 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/NumberComparator.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/NumberComparator.java
@@ -1,10 +1,9 @@
 package net.javacrumbs.jsonunit.core;
 
+import java.math.BigDecimal;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.math.BigDecimal;
-
 /**
  * Interface enabling customization of number comparison.
  */
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Option.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Option.java
index f13081489..40c3b0251 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Option.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/Option.java
@@ -38,7 +38,6 @@ public enum Option {
      */
     IGNORING_EXTRA_FIELDS,
 
-
     /**
      * Passes even if array in compared document has more items than expected.
      * Items are taken from the beginning of the expected array unless IGNORING_ARRAY_ORDER is specified.
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/AbstractNodeFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/AbstractNodeFactory.java
index 2cc3e1b47..e785ca884 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/AbstractNodeFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/AbstractNodeFactory.java
@@ -15,14 +15,13 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import net.javacrumbs.jsonunit.core.internal.Utils.JsonStringReader;
-import org.jetbrains.annotations.NotNull;
+import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
+import static net.javacrumbs.jsonunit.core.internal.Utils.toReader;
 
 import java.io.Reader;
 import java.math.BigDecimal;
-
-import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
-import static net.javacrumbs.jsonunit.core.internal.Utils.toReader;
+import net.javacrumbs.jsonunit.core.internal.Utils.JsonStringReader;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * Common superclass for node factories
@@ -64,17 +63,16 @@ final Node convertValue(Object source) {
         }
     }
 
-
     @NotNull
     protected IllegalArgumentException newParseException(String label, Reader value, Exception e) {
         if (value instanceof JsonStringReader) {
-            return new IllegalArgumentException("Can not parse " + label + " value: '" + ((JsonStringReader) value).getString() + "'", e);
+            return new IllegalArgumentException(
+                    "Can not parse " + label + " value: '" + ((JsonStringReader) value).getString() + "'", e);
         } else {
             return new IllegalArgumentException("Can not parse " + label + " value.", e);
         }
     }
 
-
     protected abstract Node doConvertValue(Object source);
 
     protected abstract Node readValue(Reader reader, String label, boolean lenient);
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayComparison.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayComparison.java
index 30d22523a..a6ad4f0aa 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayComparison.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayComparison.java
@@ -15,10 +15,9 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import net.javacrumbs.jsonunit.core.Configuration;
-
 import java.util.List;
 import java.util.stream.Collectors;
+import net.javacrumbs.jsonunit.core.Configuration;
 
 class ArrayComparison {
     private final ComparisonMatrix comparisonMatrix;
@@ -38,18 +37,22 @@ ComparisonResult compareArraysIgnoringOrder() {
     record NodeWithIndex(Node node, int index) {
 
         @Override
-            public String toString() {
-                return node.toString();
-            }
+        public String toString() {
+            return node.toString();
         }
+    }
 
     static class ComparisonResult {
         private final List<NodeWithIndex> extraValues;
         private final List<NodeWithIndex> missingValues;
 
         private ComparisonResult(ComparisonMatrix result, List<Node> expectedElements, List<Node> actualElements) {
-            extraValues = result.getExtra().stream().map(i -> new NodeWithIndex(actualElements.get(i), i)).collect(Collectors.toList());
-            missingValues = result.getMissing().stream().map(i -> new NodeWithIndex(expectedElements.get(i), i)).collect(Collectors.toList());
+            extraValues = result.getExtra().stream()
+                    .map(i -> new NodeWithIndex(actualElements.get(i), i))
+                    .collect(Collectors.toList());
+            missingValues = result.getMissing().stream()
+                    .map(i -> new NodeWithIndex(expectedElements.get(i), i))
+                    .collect(Collectors.toList());
         }
 
         public List<NodeWithIndex> getExtraValues() {
@@ -60,5 +63,4 @@ public List<NodeWithIndex> getMissingValues() {
             return missingValues;
         }
     }
-
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayUtils.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayUtils.java
index a201cf7ad..114a1e64f 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayUtils.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ArrayUtils.java
@@ -15,12 +15,12 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static java.util.stream.Collectors.toList;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import static java.util.stream.Collectors.toList;
-
 class ArrayUtils {
     static List<Double> toDoubleList(double[] source) {
         return Arrays.stream(source).boxed().collect(toList());
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ComparisonMatrix.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ComparisonMatrix.java
index 5e4705631..0a67f62f3 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ComparisonMatrix.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ComparisonMatrix.java
@@ -15,12 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import net.javacrumbs.jsonunit.core.Configuration;
-
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.List;
-
 import static java.lang.Math.min;
 import static java.util.Collections.unmodifiableList;
 import static java.util.stream.Collectors.toList;
@@ -28,13 +22,19 @@
 import static net.javacrumbs.jsonunit.core.internal.Diff.DEFAULT_DIFFERENCE_STRING;
 import static net.javacrumbs.jsonunit.core.internal.JsonUnitLogger.NULL_LOGGER;
 
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.List;
+import net.javacrumbs.jsonunit.core.Configuration;
+
 /**
  * Stores comparison result when comparing two arrays.
  */
 class ComparisonMatrix {
-    private final List<List<Integer>> equalElements; //equalElements[actualIndex] = [expectedElementIndex1, expectedElementIndex2, ...]
+    private final List<List<Integer>>
+            equalElements; // equalElements[actualIndex] = [expectedElementIndex1, expectedElementIndex2, ...]
     private final int compareFrom;
-    private final Integer[] matches; //matches[expectedElementIndex] = actualElementIndex
+    private final Integer[] matches; // matches[expectedElementIndex] = actualElementIndex
     private final List<Integer> extra;
     private final BitSet alreadyMatched;
 
@@ -42,7 +42,14 @@ class ComparisonMatrix {
     private final List<Node> expectedElements;
     private final List<Node> actualElements;
 
-    private ComparisonMatrix(List<List<Integer>> equalElements, int compareFrom, Integer[] matches, List<Integer> extra, BitSet alreadyMatched, List<Node> expectedElements, List<Node> actualElements) {
+    private ComparisonMatrix(
+            List<List<Integer>> equalElements,
+            int compareFrom,
+            Integer[] matches,
+            List<Integer> extra,
+            BitSet alreadyMatched,
+            List<Node> expectedElements,
+            List<Node> actualElements) {
         this.equalElements = equalElements;
         this.compareFrom = compareFrom;
         this.matches = matches;
@@ -53,10 +60,18 @@ private ComparisonMatrix(List<List<Integer>> equalElements, int compareFrom, Int
     }
 
     ComparisonMatrix(List<Node> expectedElements, List<Node> actualElements, Path path, Configuration configuration) {
-        this(generateEqualElements(expectedElements, actualElements, path, configuration), 0, new Integer[expectedElements.size()], new ArrayList<>(), new BitSet(), expectedElements, actualElements);
+        this(
+                generateEqualElements(expectedElements, actualElements, path, configuration),
+                0,
+                new Integer[expectedElements.size()],
+                new ArrayList<>(),
+                new BitSet(),
+                expectedElements,
+                actualElements);
     }
 
-    private static List<List<Integer>> generateEqualElements(List<Node> expectedElements, List<Node> actualElements, Path path, Configuration configuration) {
+    private static List<List<Integer>> generateEqualElements(
+            List<Node> expectedElements, List<Node> actualElements, Path path, Configuration configuration) {
         List<List<Integer>> equalElements = new ArrayList<>(actualElements.size());
 
         // Compare all elements
@@ -66,7 +81,14 @@ private static List<List<Integer>> generateEqualElements(List<Node> expectedElem
 
             for (int j = 0; j < expectedElements.size(); j++) {
                 Node expected = expectedElements.get(j);
-                Diff diff = new Diff(expected, actual, Path.create("", path.toElement(i).getFullPath()), configuration.withDifferenceListener(dummyDifferenceListener()), NULL_LOGGER, NULL_LOGGER, DEFAULT_DIFFERENCE_STRING);
+                Diff diff = new Diff(
+                        expected,
+                        actual,
+                        Path.create("", path.toElement(i).getFullPath()),
+                        configuration.withDifferenceListener(dummyDifferenceListener()),
+                        NULL_LOGGER,
+                        NULL_LOGGER,
+                        DEFAULT_DIFFERENCE_STRING);
                 if (diff.similar()) {
                     actualIsEqualTo.add(j);
                 }
@@ -74,7 +96,7 @@ private static List<List<Integer>> generateEqualElements(List<Node> expectedElem
 
             equalElements.add(unmodifiableList(actualIsEqualTo));
         }
-        //System.out.println(actualElements + " x " + expectedElements + " -> " + equalElements);
+        // System.out.println(actualElements + " x " + expectedElements + " -> " + equalElements);
         return equalElements;
     }
 
@@ -87,7 +109,8 @@ ComparisonMatrix compare() {
                 if (matches.size() == 1) {
                     recordMatch(i, matches.get(0));
                 } else if (matches.size() > 0) {
-                    // we have more matches, since comparison does not have to be transitive ([1, 2] == [2] == [2, 3]), we have to check all the possibilities
+                    // we have more matches, since comparison does not have to be transitive ([1, 2] == [2] == [2, 3]),
+                    // we have to check all the possibilities
                     for (int match : matches) {
                         ComparisonMatrix copy = copy(i + 1);
                         copy.recordMatch(i, match);
@@ -123,8 +146,11 @@ private void doSimpleMatching() {
                             recordMatch(equivalentElements.get(j), equalTo.get(j));
                         }
                     } else if (equivalentElements.size() > 1 && equalTo.size() > 1) {
-                        List<Integer> equalToUsedOnlyInEquivalentElements = getEqualToUsedOnlyInEquivalentElements(equalTo, equivalentElements);
-                        for (int j = 0; j < min(equivalentElements.size(), equalToUsedOnlyInEquivalentElements.size()); j++) {
+                        List<Integer> equalToUsedOnlyInEquivalentElements =
+                                getEqualToUsedOnlyInEquivalentElements(equalTo, equivalentElements);
+                        for (int j = 0;
+                                j < min(equivalentElements.size(), equalToUsedOnlyInEquivalentElements.size());
+                                j++) {
                             recordMatch(equivalentElements.get(j), equalTo.get(j));
                         }
                     }
@@ -138,7 +164,8 @@ private void doSimpleMatching() {
      * we iterate over actual elements that are not in equivalentElements and from equalTo remove those
      * that are used outside equivalent elements
      */
-    private List<Integer> getEqualToUsedOnlyInEquivalentElements(List<Integer> equalTo, List<Integer> equivalentElements) {
+    private List<Integer> getEqualToUsedOnlyInEquivalentElements(
+            List<Integer> equalTo, List<Integer> equivalentElements) {
         List<Integer> result = new ArrayList<>(equalTo);
         for (int i = 0; i < equalElements.size(); i++) {
             if (!alreadyMatched.get(i)) {
@@ -162,7 +189,6 @@ private List<Integer> getEquivalentElements(List<Integer> equalTo) {
         return equivalentElments;
     }
 
-
     private void addExtra(int index) {
         extra.add(index);
     }
@@ -172,7 +198,14 @@ private List<Integer> getEqualValues(int actualIndex) {
     }
 
     private ComparisonMatrix copy(int compareFrom) {
-        return new ComparisonMatrix(new ArrayList<>(equalElements), compareFrom, matches.clone(), new ArrayList<>(extra), (BitSet) alreadyMatched.clone(), expectedElements, actualElements);
+        return new ComparisonMatrix(
+                new ArrayList<>(equalElements),
+                compareFrom,
+                matches.clone(),
+                new ArrayList<>(extra),
+                (BitSet) alreadyMatched.clone(),
+                expectedElements,
+                actualElements);
     }
 
     private void recordMatch(int actualIndex, int expectedIndex) {
@@ -180,7 +213,11 @@ private void recordMatch(int actualIndex, int expectedIndex) {
         // remove all matches of expectedIndex
         for (int i = 0; i < equalElements.size(); i++) {
             if (!alreadyMatched.get(i)) {
-                equalElements.set(i, equalElements.get(i).stream().filter(n -> n != expectedIndex).collect(toList()));
+                equalElements.set(
+                        i,
+                        equalElements.get(i).stream()
+                                .filter(n -> n != expectedIndex)
+                                .collect(toList()));
             }
         }
         alreadyMatched.set(actualIndex);
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Context.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Context.java
index edf8708e6..06e643eeb 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Context.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Context.java
@@ -15,18 +15,28 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import net.javacrumbs.jsonunit.core.Configuration;
-
 import static net.javacrumbs.jsonunit.core.internal.JsonUtils.wrapDeserializedObject;
 
+import net.javacrumbs.jsonunit.core.Configuration;
+
 record Context(Node expectedNode, Node actualNode, Path expectedPath, Path actualPath, Configuration configuration) {
 
     Context inField(String key) {
-        return new Context(expectedNode.get(key), actualNode.get(key), expectedPath.toField(key), actualPath.toField(key), configuration);
+        return new Context(
+                expectedNode.get(key),
+                actualNode.get(key),
+                expectedPath.toField(key),
+                actualPath.toField(key),
+                configuration);
     }
 
     Context toElement(int i) {
-        return new Context(expectedNode.element(i), actualNode.element(i), expectedPath.toElement(i), actualPath.toElement(i), configuration);
+        return new Context(
+                expectedNode.element(i),
+                actualNode.element(i),
+                expectedPath.toElement(i),
+                actualPath.toElement(i),
+                configuration);
     }
 
     Context missingElement(int i) {
@@ -38,6 +48,11 @@ Context extraElement(int i) {
     }
 
     Context length(Object expectedLength) {
-        return new Context(wrapDeserializedObject(expectedLength), wrapDeserializedObject(actualNode.size()), expectedPath.length(), actualPath.length(), configuration);
+        return new Context(
+                wrapDeserializedObject(expectedLength),
+                wrapDeserializedObject(actualNode.size()),
+                expectedPath.length(),
+                actualPath.length(),
+                configuration);
     }
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Converter.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Converter.java
index 55a84be2c..9ea7763b6 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Converter.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Converter.java
@@ -15,13 +15,12 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import static net.javacrumbs.jsonunit.core.internal.ClassUtils.isClassPresent;
 
 import java.util.ArrayList;
 import java.util.List;
-
-import static net.javacrumbs.jsonunit.core.internal.ClassUtils.isClassPresent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Converts object to Node using {@link NodeFactory}.
@@ -29,21 +28,16 @@
 record Converter(List<NodeFactory> factories) {
     static final String LIBRARIES_PROPERTY_NAME = "json-unit.libraries";
 
-    private static final boolean jackson2Present =
-        isClassPresent("com.fasterxml.jackson.databind.ObjectMapper") &&
-            isClassPresent("com.fasterxml.jackson.core.JsonGenerator");
+    private static final boolean jackson2Present = isClassPresent("com.fasterxml.jackson.databind.ObjectMapper")
+            && isClassPresent("com.fasterxml.jackson.core.JsonGenerator");
 
-    private static final boolean gsonPresent =
-        isClassPresent("com.google.gson.Gson");
+    private static final boolean gsonPresent = isClassPresent("com.google.gson.Gson");
 
-    private static final boolean jsonOrgPresent =
-        isClassPresent("org.json.JSONObject");
+    private static final boolean jsonOrgPresent = isClassPresent("org.json.JSONObject");
 
-    private static final boolean moshiPresent =
-        isClassPresent("com.squareup.moshi.Moshi");
+    private static final boolean moshiPresent = isClassPresent("com.squareup.moshi.Moshi");
 
-    private static final boolean johnzonPresent =
-        isClassPresent("org.apache.johnzon.mapper.Mapper");
+    private static final boolean johnzonPresent = isClassPresent("org.apache.johnzon.mapper.Mapper");
 
     Converter {
         if (factories.isEmpty()) {
@@ -65,7 +59,8 @@ static Converter createDefaultConverter() {
         }
 
         if (factories.isEmpty()) {
-            throw new IllegalStateException("Please add either json.org, Jackson 1.x, Jackson 2.x, Johnzon or Gson to the classpath");
+            throw new IllegalStateException(
+                    "Please add either json.org, Jackson 1.x, Jackson 2.x, Johnzon or Gson to the classpath");
         }
         return new Converter(factories);
     }
@@ -109,6 +104,7 @@ private static List<NodeFactory> createDefaultFactories() {
         }
         return factories;
     }
+
     @NotNull
     Node convertToNode(@Nullable Object source, String label, boolean lenient) {
         for (int i = 0; i < factories.size(); i++) {
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DefaultNumberComparator.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DefaultNumberComparator.java
index 95493af55..078fe8027 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DefaultNumberComparator.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DefaultNumberComparator.java
@@ -1,14 +1,14 @@
 package net.javacrumbs.jsonunit.core.internal;
 
+import java.math.BigDecimal;
 import net.javacrumbs.jsonunit.core.NumberComparator;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.math.BigDecimal;
-
 public class DefaultNumberComparator implements NumberComparator {
     @Override
-    public boolean compare(@NotNull BigDecimal expectedValue, @NotNull BigDecimal actualValue, @Nullable BigDecimal tolerance) {
+    public boolean compare(
+            @NotNull BigDecimal expectedValue, @NotNull BigDecimal actualValue, @Nullable BigDecimal tolerance) {
         if (tolerance != null) {
             BigDecimal diff = expectedValue.subtract(actualValue).abs();
             return diff.compareTo(tolerance) <= 0;
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Diff.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Diff.java
index e49e5a7cd..f3c46757a 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Diff.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Diff.java
@@ -15,28 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import net.javacrumbs.jsonunit.core.Configuration;
-import net.javacrumbs.jsonunit.core.Option;
-import net.javacrumbs.jsonunit.core.internal.ArrayComparison.ComparisonResult;
-import net.javacrumbs.jsonunit.core.internal.ArrayComparison.NodeWithIndex;
-import net.javacrumbs.jsonunit.core.listener.Difference;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.TreeSet;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
 import static java.util.Collections.emptySet;
 import static net.javacrumbs.jsonunit.core.Option.IGNORING_ARRAY_ORDER;
 import static net.javacrumbs.jsonunit.core.Option.IGNORING_EXTRA_ARRAY_ITEMS;
@@ -54,6 +32,26 @@
 import static net.javacrumbs.jsonunit.core.internal.Node.KeyValue;
 import static net.javacrumbs.jsonunit.core.internal.Node.NodeType;
 
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import net.javacrumbs.jsonunit.core.Configuration;
+import net.javacrumbs.jsonunit.core.Option;
+import net.javacrumbs.jsonunit.core.internal.ArrayComparison.ComparisonResult;
+import net.javacrumbs.jsonunit.core.internal.ArrayComparison.NodeWithIndex;
+import net.javacrumbs.jsonunit.core.listener.Difference;
 
 /**
  * Compares JSON structures. Mainly for internal use, the API might be more volatile than the rest.
@@ -62,16 +60,19 @@
  */
 public class Diff {
 
-    // DO NOT remove redundant character escapes, they are needed for Android https://github.com/lukas-krecan/JsonUnit/pull/227
+    // DO NOT remove redundant character escapes, they are needed for Android
+    // https://github.com/lukas-krecan/JsonUnit/pull/227
     private static final Pattern ANY_NUMBER_PLACEHOLDER = Pattern.compile("[$#]\\{json-unit.any-number\\}");
     private static final Pattern ANY_BOOLEAN_PLACEHOLDER = Pattern.compile("[$#]\\{json-unit.any-boolean\\}");
     private static final Pattern ANY_STRING_PLACEHOLDER = Pattern.compile("[$#]\\{json-unit.any-string\\}");
 
     private static final Pattern REGEX_PLACEHOLDER = Pattern.compile("[$#]\\{json-unit.regex\\}(.*)");
-    private static final Pattern MATCHER_PLACEHOLDER_PATTERN = Pattern.compile("[$#]\\{json-unit.matches:(.+?)\\}(.*)", Pattern.DOTALL);
+    private static final Pattern MATCHER_PLACEHOLDER_PATTERN =
+            Pattern.compile("[$#]\\{json-unit.matches:(.+?)\\}(.*)", Pattern.DOTALL);
 
     private static final JsonUnitLogger DEFAULT_DIFF_LOGGER = createLogger("net.javacrumbs.jsonunit.difference.diff");
-    private static final JsonUnitLogger DEFAULT_VALUE_LOGGER = createLogger("net.javacrumbs.jsonunit.difference.values");
+    private static final JsonUnitLogger DEFAULT_VALUE_LOGGER =
+            createLogger("net.javacrumbs.jsonunit.difference.values");
     static final String DEFAULT_DIFFERENCE_STRING = "expected: <%s> but was: <%s>";
 
     private final Node expectedRoot;
@@ -87,7 +88,14 @@ public class Diff {
     private final JsonUnitLogger valuesLogger;
     private final String differenceString;
 
-    Diff(Node expected, Node actual, Path startPath, Configuration configuration, JsonUnitLogger diffLogger, JsonUnitLogger valuesLogger, String differenceString) {
+    Diff(
+            Node expected,
+            Node actual,
+            Path startPath,
+            Configuration configuration,
+            JsonUnitLogger diffLogger,
+            JsonUnitLogger valuesLogger,
+            String differenceString) {
         this.expectedRoot = expected;
         this.actualRoot = actual;
         this.startPath = startPath;
@@ -96,24 +104,45 @@ public class Diff {
         this.valuesLogger = valuesLogger;
         this.pathsToBeIgnored = PathMatcher.create(configuration.getPathsToBeIgnored());
         this.specificPathOptions = configuration.getPathOptions().stream()
-                .flatMap(PathOptionMatcher::createMatchersFromPathOption).collect(Collectors.groupingBy(PathOptionMatcher::getOption));
+                .flatMap(PathOptionMatcher::createMatchersFromPathOption)
+                .collect(Collectors.groupingBy(PathOptionMatcher::getOption));
         this.differenceString = differenceString;
     }
 
-    public static Diff create(Object expected, Object actual, String actualName, String path, Configuration configuration) {
+    public static Diff create(
+            Object expected, Object actual, String actualName, String path, Configuration configuration) {
         if (actual instanceof JsonSource) {
-            return create(expected, actual, actualName, Path.create(path, ((JsonSource) actual).getPathPrefix()), configuration);
+            return create(
+                    expected,
+                    actual,
+                    actualName,
+                    Path.create(path, ((JsonSource) actual).getPathPrefix()),
+                    configuration);
         } else {
             return create(expected, actual, actualName, Path.create(path, ""), configuration);
         }
     }
 
-    public static Diff create(Object expected, Object actual, String actualName, Path path, Configuration configuration) {
-        return createInternal(expected, actual,  actualName, path, configuration, DEFAULT_DIFFERENCE_STRING);
+    public static Diff create(
+            Object expected, Object actual, String actualName, Path path, Configuration configuration) {
+        return createInternal(expected, actual, actualName, path, configuration, DEFAULT_DIFFERENCE_STRING);
     }
 
-    public static Diff createInternal(Object expected, Object actual, String actualName, Path path, Configuration configuration, String differenceString) {
-        return new Diff(convertToJson(quoteIfNeeded(expected), "expected", true), convertToJson(actual, actualName, false), path, configuration, DEFAULT_DIFF_LOGGER, DEFAULT_VALUE_LOGGER, differenceString);
+    public static Diff createInternal(
+            Object expected,
+            Object actual,
+            String actualName,
+            Path path,
+            Configuration configuration,
+            String differenceString) {
+        return new Diff(
+                convertToJson(quoteIfNeeded(expected), "expected", true),
+                convertToJson(actual, actualName, false),
+                path,
+                configuration,
+                DEFAULT_DIFF_LOGGER,
+                DEFAULT_VALUE_LOGGER,
+                differenceString);
     }
 
     private void compare() {
@@ -148,9 +177,8 @@ private void compareObjectNodes(Context context) {
 
         if (!expectedKeys.equals(actualKeys)) {
             Set<String> missingKeys = getMissingKeys(expectedKeys, actualKeys);
-            Set<String> extraKeys = removeNullExtraKeysWhereNeeded(actual,
-                    getExtraKeys(context.actualPath(), expectedKeys, actualKeys),
-                    context.actualPath());
+            Set<String> extraKeys = removeNullExtraKeysWhereNeeded(
+                    actual, getExtraKeys(context.actualPath(), expectedKeys, actualKeys), context.actualPath());
 
             removePathsToBeIgnored(path, extraKeys);
             removePathsToBeIgnored(path, missingKeys);
@@ -166,7 +194,14 @@ private void compareObjectNodes(Context context) {
                 }
                 String missingKeysMessage = getMissingKeysMessage(missingKeys, path);
                 String extraKeysMessage = getExtraKeysMessage(extraKeys, path);
-                structureDifferenceFound(context, "Different keys found in node \"%s\"%s%s, " + differenceString(), path, missingKeysMessage, extraKeysMessage, normalize(expected), normalize(actual));
+                structureDifferenceFound(
+                        context,
+                        "Different keys found in node \"%s\"%s%s, " + differenceString(),
+                        path,
+                        missingKeysMessage,
+                        extraKeysMessage,
+                        normalize(expected),
+                        normalize(actual));
             }
         }
 
@@ -186,8 +221,9 @@ private String normalize(Node node) {
     }
 
     private void reportDifference(Difference difference) {
-        configuration.getDifferenceListener().diff(difference,
-                differenceContext(configuration, actualRoot, expectedRoot));
+        configuration
+                .getDifferenceListener()
+                .diff(difference, differenceContext(configuration, actualRoot, expectedRoot));
     }
 
     private void removePathsToBeIgnored(Path path, Set<String> extraKeys) {
@@ -202,14 +238,14 @@ private void removePathsToBeIgnored(Path path, Set<String> extraKeys) {
     private Set<String> removeNullExtraKeysWhereNeeded(Node actual, Set<String> extraKeys, Path actualPath) {
         Set<String> notNullExtraKeys = new TreeSet<>();
         for (String extraKey : extraKeys) {
-            if (!hasOption(actualPath.toField(extraKey), TREATING_NULL_AS_ABSENT) || !actual.get(extraKey).isNull()) {
+            if (!hasOption(actualPath.toField(extraKey), TREATING_NULL_AS_ABSENT)
+                    || !actual.get(extraKey).isNull()) {
                 notNullExtraKeys.add(extraKey);
             }
         }
         return notNullExtraKeys;
     }
 
-
     private static String getMissingKeysMessage(Set<String> missingKeys, Path path) {
         if (!missingKeys.isEmpty()) {
             return ", missing: " + appendKeysToPrefix(missingKeys, path);
@@ -283,7 +319,7 @@ private void compareNodes(Context context) {
 
         Path fieldPath = context.actualPath();
 
-        //ignoring value
+        // ignoring value
         if (expectedNodeType == NodeType.STRING && configuration.shouldIgnore(expectedNode.asText())) {
             return;
         }
@@ -312,7 +348,12 @@ private void compareNodes(Context context) {
         }
 
         if (!expectedNodeType.equals(actualNodeType)) {
-            reportValueDifference(context, "Different value found in node \"%s\", " + differenceString() + ".", fieldPath, quoteTextValue(expectedNode), quoteTextValue(actualNode));
+            reportValueDifference(
+                    context,
+                    "Different value found in node \"%s\", " + differenceString() + ".",
+                    fieldPath,
+                    quoteTextValue(expectedNode),
+                    quoteTextValue(actualNode));
         } else {
             switch (expectedNodeType) {
                 case OBJECT:
@@ -330,11 +371,13 @@ private void compareNodes(Context context) {
                     if (!hasOption(context.actualPath(), IGNORING_VALUES)) {
                         BigDecimal tolerance = configuration.getTolerance();
                         if (!configuration.getNumberComparator().compare(expectedValue, actualValue, tolerance)) {
-                            BigDecimal diff = expectedValue.subtract(actualValue).abs();
-                            List<Object> arguments = Arrays.asList(fieldPath, quoteTextValue(expectedValue), quoteTextValue(actualValue));
+                            BigDecimal diff =
+                                    expectedValue.subtract(actualValue).abs();
+                            List<Object> arguments = Arrays.asList(
+                                    fieldPath, quoteTextValue(expectedValue), quoteTextValue(actualValue));
                             String message = "Different value found in node \"%s\", " + differenceString();
                             if (tolerance != null && tolerance.compareTo(BigDecimal.ZERO) != 0) {
-                                message +=  ", difference is " + diff + ", tolerance is " + tolerance;
+                                message += ", difference is " + diff + ", tolerance is " + tolerance;
                             } else {
                                 message += ".";
                             }
@@ -346,7 +389,7 @@ private void compareNodes(Context context) {
                     compareValues(context, expectedNode.asBoolean(), actualNode.asBoolean());
                     break;
                 case NULL:
-                    //nothing
+                    // nothing
                     break;
                 default:
                     throw new IllegalStateException("Unexpected node type " + expectedNodeType);
@@ -355,7 +398,8 @@ private void compareNodes(Context context) {
     }
 
     private boolean shouldIgnoreElement(Node expectedNode) {
-        return expectedNode.getNodeType() == NodeType.STRING && "${json-unit.ignore-element}".equals(expectedNode.asText());
+        return expectedNode.getNodeType() == NodeType.STRING
+                && "${json-unit.ignore-element}".equals(expectedNode.asText());
     }
 
     private boolean shouldIgnorePath(Path fieldPath) {
@@ -371,7 +415,7 @@ private boolean checkMatcher(Context context) {
             if (patternMatcher.matches()) {
                 String matcherName = patternMatcher.group(1);
                 new HamcrestHandler(configuration, this::reportValueDifference, this::structureDifferenceFound)
-                    .matchHamcrestMatcher(context, actualNode, patternMatcher, matcherName);
+                        .matchHamcrestMatcher(context, actualNode, patternMatcher, matcherName);
                 return true;
             }
         }
@@ -382,11 +426,17 @@ private boolean checkAny(NodeType type, Pattern placeholder, String name, Contex
         Node expectedNode = context.expectedNode();
         Node actualNode = context.actualNode();
 
-        if (expectedNode.getNodeType() == NodeType.STRING && placeholder.matcher(expectedNode.asText()).matches()) {
+        if (expectedNode.getNodeType() == NodeType.STRING
+                && placeholder.matcher(expectedNode.asText()).matches()) {
             if (actualNode.getNodeType() == type) {
                 return true;
             } else {
-                reportValueDifference(context, "Different value found in node \"%s\", " + differenceString() + ".", context.actualPath(), name, quoteTextValue(actualNode));
+                reportValueDifference(
+                        context,
+                        "Different value found in node \"%s\", " + differenceString() + ".",
+                        context.actualPath(),
+                        name,
+                        quoteTextValue(actualNode));
                 return true;
             }
         }
@@ -405,18 +455,27 @@ private void compareStringValues(Context context) {
         if (regexpMatcher.matches()) {
             String pattern = regexpMatcher.group(1);
             if (!actualValue.matches(pattern)) {
-                reportValueDifference(context, "Different value found in node \"%s\". Pattern %s did not match %s.", path, quoteTextValue(pattern), quoteTextValue(actualValue));
+                reportValueDifference(
+                        context,
+                        "Different value found in node \"%s\". Pattern %s did not match %s.",
+                        path,
+                        quoteTextValue(pattern),
+                        quoteTextValue(actualValue));
             }
         } else {
             compareValues(context, expectedValue, actualValue);
         }
     }
 
-
     private void compareValues(Context context, Object expectedValue, Object actualValue) {
         if (!hasOption(context.actualPath(), IGNORING_VALUES)) {
             if (!expectedValue.equals(actualValue)) {
-                reportValueDifference(context, "Different value found in node \"%s\", " + differenceString() + ".", context.actualPath(), quoteTextValue(expectedValue), quoteTextValue(actualValue));
+                reportValueDifference(
+                        context,
+                        "Different value found in node \"%s\", " + differenceString() + ".",
+                        context.actualPath(),
+                        quoteTextValue(expectedValue),
+                        quoteTextValue(actualValue));
             }
         }
     }
@@ -442,7 +501,6 @@ public static Object quoteTextValue(Object value) {
         }
     }
 
-
     private void compareArrayNodes(Context context) {
         Node expectedNode = context.expectedNode();
         Node actualNode = context.actualNode();
@@ -451,15 +509,24 @@ private void compareArrayNodes(Context context) {
         List<Node> expectedElements = asList(expectedNode.arrayElements());
         List<Node> actualElements = asList(actualNode.arrayElements());
 
-
         if (failOnExtraArrayItems(context.actualPath())) {
             if (expectedElements.size() != actualElements.size()) {
-                structureDifferenceFound(context.length(expectedElements.size()), "Array \"%s\" has different length, expected: <%d> but was: <%d>.", path, expectedElements.size(), actualElements.size());
+                structureDifferenceFound(
+                        context.length(expectedElements.size()),
+                        "Array \"%s\" has different length, expected: <%d> but was: <%d>.",
+                        path,
+                        expectedElements.size(),
+                        actualElements.size());
             }
         } else {
             // if we expect more elements in the array than we get, it's error even when IGNORING_EXTRA_ARRAY_ITEMS
             if (expectedElements.size() > actualElements.size()) {
-                structureDifferenceFound(context.length("at least " + expectedElements.size()), "Array \"%s\" has invalid length, expected: <at least %d> but was: <%d>.", path, expectedElements.size(), actualElements.size());
+                structureDifferenceFound(
+                        context.length("at least " + expectedElements.size()),
+                        "Array \"%s\" has invalid length, expected: <at least %d> but was: <%d>.",
+                        path,
+                        expectedElements.size(),
+                        actualElements.size());
             }
         }
 
@@ -467,35 +534,67 @@ private void compareArrayNodes(Context context) {
             ComparisonResult arrayComparison = compareArraysIgnoringOrder(expectedElements, actualElements, path);
             List<NodeWithIndex> missingValues = arrayComparison.getMissingValues();
             List<NodeWithIndex> extraValues = arrayComparison.getExtraValues();
-            if (expectedElements.size() == actualElements.size() && missingValues.size() == 1 && extraValues.size() == 1) {
+            if (expectedElements.size() == actualElements.size()
+                    && missingValues.size() == 1
+                    && extraValues.size() == 1) {
                 // handling special case where only one difference is found.
                 NodeWithIndex missing = missingValues.get(0);
                 NodeWithIndex extra = extraValues.get(0);
 
                 Path expectedPath = context.expectedPath().toElement(missing.index());
                 Path actualPath = context.actualPath().toElement(extra.index());
-                valueDifferenceFound(context, "Different value found when comparing expected array element %s to actual element %s.", expectedPath, actualPath);
+                valueDifferenceFound(
+                        context,
+                        "Different value found when comparing expected array element %s to actual element %s.",
+                        expectedPath,
+                        actualPath);
                 compareNodes(new Context(missing.node(), extra.node(), expectedPath, actualPath, configuration));
-            } else if (failOnExtraArrayItems(context.actualPath()) && (!missingValues.isEmpty() || !extraValues.isEmpty())) {
+            } else if (failOnExtraArrayItems(context.actualPath())
+                    && (!missingValues.isEmpty() || !extraValues.isEmpty())) {
                 reportMissingValues(context, missingValues);
                 reportExtraValues(context, extraValues);
 
-                valueDifferenceFound(context, "Array \"%s\" has different content. Missing values: %s, extra values: %s, expected: <%s> but was: <%s>", path, missingValues, extraValues, expectedNode, actualNode);
+                valueDifferenceFound(
+                        context,
+                        "Array \"%s\" has different content. Missing values: %s, extra values: %s, expected: <%s> but was: <%s>",
+                        path,
+                        missingValues,
+                        extraValues,
+                        expectedNode,
+                        actualNode);
             } else if (!missingValues.isEmpty()) {
                 reportMissingValues(context, missingValues);
-                valueDifferenceFound(context, "Array \"%s\" has different content. Missing values: %s, expected: <%s> but was: <%s>", path, missingValues, expectedNode, actualNode);
+                valueDifferenceFound(
+                        context,
+                        "Array \"%s\" has different content. Missing values: %s, expected: <%s> but was: <%s>",
+                        path,
+                        missingValues,
+                        expectedNode,
+                        actualNode);
             }
         } else {
             if (expectedElements.size() > actualElements.size()) {
                 for (int i = actualElements.size(); i < expectedElements.size(); i++) {
                     reportDifference(DifferenceImpl.missing(context.missingElement(i)));
                 }
-                valueDifferenceFound(context, "Array \"%s\" has different content. Missing values: %s, expected: <%s> but was: <%s>", path, expectedElements.subList(actualElements.size(), expectedElements.size()), expectedNode, actualNode);
+                valueDifferenceFound(
+                        context,
+                        "Array \"%s\" has different content. Missing values: %s, expected: <%s> but was: <%s>",
+                        path,
+                        expectedElements.subList(actualElements.size(), expectedElements.size()),
+                        expectedNode,
+                        actualNode);
             } else if (failOnExtraArrayItems(context.actualPath()) && expectedElements.size() < actualElements.size()) {
                 for (int i = expectedElements.size(); i < actualElements.size(); i++) {
                     reportDifference(DifferenceImpl.extra(context.extraElement(i)));
                 }
-                valueDifferenceFound(context, "Array \"%s\" has different content. Extra values: %s, expected: <%s> but was: <%s>", path, actualElements.subList(expectedElements.size(), actualElements.size()), expectedNode, actualNode);
+                valueDifferenceFound(
+                        context,
+                        "Array \"%s\" has different content. Extra values: %s, expected: <%s> but was: <%s>",
+                        path,
+                        actualElements.subList(expectedElements.size(), actualElements.size()),
+                        expectedNode,
+                        actualNode);
             }
             for (int i = 0; i < Math.min(expectedElements.size(), actualElements.size()); i++) {
                 compareNodes(context.toElement(i));
@@ -515,16 +614,15 @@ private void reportExtraValues(Context context, List<NodeWithIndex> extraValues)
         }
     }
 
-    private ComparisonResult compareArraysIgnoringOrder(List<Node> expectedElements, List<Node> actualElements, Path path) {
+    private ComparisonResult compareArraysIgnoringOrder(
+            List<Node> expectedElements, List<Node> actualElements, Path path) {
         return new ArrayComparison(expectedElements, actualElements, path, configuration).compareArraysIgnoringOrder();
     }
 
-
     private boolean failOnExtraArrayItems(Path path) {
         return !hasOption(path, IGNORING_EXTRA_ARRAY_ITEMS);
     }
 
-
     private List<Node> asList(Iterator<Node> elements) {
         List<Node> result = new ArrayList<>();
         while (elements.hasNext()) {
@@ -534,7 +632,6 @@ private List<Node> asList(Iterator<Node> elements) {
         return Collections.unmodifiableList(result);
     }
 
-
     private void structureDifferenceFound(Context context, String message, Object... arguments) {
         differences.add(new JsonDifference(context, message, arguments));
     }
@@ -554,7 +651,6 @@ private Set<String> commonFields(Map<String, Node> expectedFields, Map<String, N
         return Collections.unmodifiableSet(result);
     }
 
-
     public boolean similar() {
         compare();
         return differences.isEmpty();
@@ -566,7 +662,10 @@ private void logDifferences() {
                 diffLogger.log(getDifferences().trim());
             }
             if (valuesLogger.isEnabled()) {
-                valuesLogger.log("Comparing expected:\n{}\n------------\nwith actual:\n{}\n", expectedRoot, startPath.getNode(actualRoot));
+                valuesLogger.log(
+                        "Comparing expected:\n{}\n------------\nwith actual:\n{}\n",
+                        expectedRoot,
+                        startPath.getNode(actualRoot));
             }
         }
     }
@@ -603,8 +702,7 @@ private String getDifferences() {
         return formatDifferences("", differences);
     }
 
-
-    public void failIfDifferent(){
+    public void failIfDifferent() {
         failIfDifferent(null);
     }
 
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceContextImpl.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceContextImpl.java
index 584071edd..0b2de5cf0 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceContextImpl.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceContextImpl.java
@@ -30,8 +30,8 @@ private DifferenceContextImpl(Configuration configuration, Node actualSource, No
         this.expectedSource = expectedSource;
     }
 
-
-    static DifferenceContextImpl differenceContext(Configuration configuration, Node actualSource, Node expectedSource) {
+    static DifferenceContextImpl differenceContext(
+            Configuration configuration, Node actualSource, Node expectedSource) {
         return new DifferenceContextImpl(configuration, actualSource, expectedSource);
     }
 
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceImpl.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceImpl.java
index 93b68c202..8b05cb1ad 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceImpl.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/DifferenceImpl.java
@@ -50,7 +50,8 @@ public Object getExpected() {
 
     @Override
     public String toString() {
-        return getType() + " Expected " + getExpected() + " in " + getExpectedPath() + " got " + getActual() + " in " + getActualPath();
+        return getType() + " Expected " + getExpected() + " in " + getExpectedPath() + " got " + getActual() + " in "
+                + getActualPath();
     }
 
     private static class MissingDifference extends DifferenceImpl {
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Differences.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Differences.java
index 2ec9f93b9..3b52f70c2 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Differences.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Differences.java
@@ -24,8 +24,7 @@
 class Differences {
     private final List<JsonDifference> differences = new ArrayList<>();
 
-    Differences() {
-    }
+    Differences() {}
 
     void add(JsonDifference jsonDifference) {
         differences.add(jsonDifference);
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionFactory.java
index 7804644de..394f8f96f 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionFactory.java
@@ -1,13 +1,12 @@
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.opentest4j.AssertionFailedError;
-import org.opentest4j.MultipleFailuresError;
+import static java.util.stream.Collectors.toList;
+import static net.javacrumbs.jsonunit.core.internal.ExceptionUtils.formatDifferences;
 
 import java.util.Collections;
 import java.util.List;
-
-import static java.util.stream.Collectors.toList;
-import static net.javacrumbs.jsonunit.core.internal.ExceptionUtils.formatDifferences;
+import org.opentest4j.AssertionFailedError;
+import org.opentest4j.MultipleFailuresError;
 
 interface ExceptionFactory {
     AssertionError createException(String message, Differences diffs);
@@ -32,7 +31,10 @@ public AssertionError createException(String message, Differences diffs) {
         List<JsonDifference> differences = diffs.getDifferences();
         if (differences.size() == 1) {
             JsonDifference difference = differences.get(0);
-            return new AssertionFailedError(formatDifferences(message, Collections.singletonList(difference)), difference.getExpected(), difference.getActual());
+            return new AssertionFailedError(
+                    formatDifferences(message, Collections.singletonList(difference)),
+                    difference.getExpected(),
+                    difference.getActual());
         } else {
             return new JsonAssertError(message, diffs);
         }
@@ -43,17 +45,20 @@ private static class JsonAssertError extends MultipleFailuresError {
         private final Differences differences;
 
         JsonAssertError(String message, Differences differences) {
-            super(message, differences.getDifferences().stream().map(JsonAssertError::getError).collect(toList()));
+            super(
+                    message,
+                    differences.getDifferences().stream()
+                            .map(JsonAssertError::getError)
+                            .collect(toList()));
             this.message = message;
             this.differences = differences;
         }
 
         private static AssertionFailedError getError(JsonDifference difference) {
             return new AssertionFailedError(
-                difference.getMessage(),
-                difference.getExpected().getValue(),
-                difference.getActual().getValue()
-            );
+                    difference.getMessage(),
+                    difference.getExpected().getValue(),
+                    difference.getActual().getValue());
         }
 
         @Override
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionUtils.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionUtils.java
index fd1064eb5..f5e47dd42 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionUtils.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/ExceptionUtils.java
@@ -15,15 +15,16 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import java.util.List;
-
 import static net.javacrumbs.jsonunit.core.internal.ClassUtils.isClassPresent;
 
+import java.util.List;
+
 class ExceptionUtils {
     private static final String ROOT_MESSAGE = "JSON documents are different:\n";
 
-    private static final ExceptionFactory exceptionFactory
-        = isClassPresent("org.opentest4j.AssertionFailedError") ? new Opentest4jExceptionFactory() : new BasicExceptionFactory();
+    private static final ExceptionFactory exceptionFactory = isClassPresent("org.opentest4j.AssertionFailedError")
+            ? new Opentest4jExceptionFactory()
+            : new BasicExceptionFactory();
 
     static String formatDifferences(String message, Differences differences) {
         return formatDifferences(message, differences.getDifferences());
@@ -53,5 +54,5 @@ private static void addHeading(String message, StringBuilder builder) {
                 builder.append('[').append(message).append("] ");
             }
         }
-     }
+    }
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GenericNodeBuilder.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GenericNodeBuilder.java
index ece116f38..d760d3e6d 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GenericNodeBuilder.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GenericNodeBuilder.java
@@ -15,17 +15,16 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.jetbrains.annotations.NotNull;
+import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toBoolList;
+import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toDoubleList;
+import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toIntList;
 
 import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-
-import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toBoolList;
-import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toDoubleList;
-import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toIntList;
+import org.jetbrains.annotations.NotNull;
 
 class GenericNodeBuilder implements NodeBuilder {
     private static final GenericNodeBuilder INSTANCE = new GenericNodeBuilder();
@@ -64,7 +63,7 @@ public Node newNode(Object object) {
         }
     }
 
-    static abstract class NodeSkeleton extends AbstractNode {
+    abstract static class NodeSkeleton extends AbstractNode {
         @Override
         public Node element(int index) {
             return MISSING_NODE;
@@ -156,7 +155,6 @@ public String toString() {
         }
     }
 
-
     static final class StringNode extends GenericNodeBuilder.NodeSkeleton {
         private final String value;
 
@@ -339,10 +337,11 @@ public String toString() {
             Iterator<Node.KeyValue> entries = this.iterator();
             while (entries.hasNext()) {
                 Node.KeyValue entry = entries.next();
-                builder
-                    .append('"').append(entry.getKey()).append('"')
-                    .append(":")
-                    .append(entry.getValue());
+                builder.append('"')
+                        .append(entry.getKey())
+                        .append('"')
+                        .append(":")
+                        .append(entry.getValue());
                 if (entries.hasNext()) {
                     builder.append(",");
                 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GsonNodeFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GsonNodeFactory.java
index 24cbaa878..91987019b 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GsonNodeFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/GsonNodeFactory.java
@@ -15,6 +15,7 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
@@ -25,14 +26,11 @@
 import com.google.gson.JsonParser;
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSyntaxException;
-
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.util.Iterator;
 import java.util.Map;
 
-import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
-
 /**
  * Deserializes node using Gson
  */
@@ -98,11 +96,11 @@ public Node element(int index) {
             }
         }
 
-
         @Override
         public Iterator<KeyValue> fields() {
             if (jsonNode instanceof JsonObject) {
-                final Iterator<Map.Entry<String, JsonElement>> iterator = ((JsonObject) jsonNode).entrySet().iterator();
+                final Iterator<Map.Entry<String, JsonElement>> iterator =
+                        ((JsonObject) jsonNode).entrySet().iterator();
                 return new Iterator<>() {
                     @Override
                     public boolean hasNext() {
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/HamcrestHandler.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/HamcrestHandler.java
index 3ebf1267c..9e4945100 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/HamcrestHandler.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/HamcrestHandler.java
@@ -1,15 +1,13 @@
 package net.javacrumbs.jsonunit.core.internal;
 
+import static net.javacrumbs.jsonunit.core.internal.Diff.quoteTextValue;
+
+import java.util.regex.Matcher;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ParametrizedMatcher;
 import org.hamcrest.Description;
 import org.hamcrest.StringDescription;
 
-import java.util.regex.Matcher;
-
-import static net.javacrumbs.jsonunit.core.internal.Diff.quoteTextValue;
-
-
 /**
  * Hamcrest dependent classes moved here so we can theoretically work without it.
  */
@@ -18,7 +16,10 @@ class HamcrestHandler {
     private final DifferenceReporter valueDifferenceReporter;
     private final DifferenceReporter structureDifferenceReporter;
 
-    HamcrestHandler(Configuration configuration, DifferenceReporter valueDifferenceReporter, DifferenceReporter structureDifferenceReporter) {
+    HamcrestHandler(
+            Configuration configuration,
+            DifferenceReporter valueDifferenceReporter,
+            DifferenceReporter structureDifferenceReporter) {
         this.configuration = configuration;
         this.valueDifferenceReporter = valueDifferenceReporter;
         this.structureDifferenceReporter = structureDifferenceReporter;
@@ -34,7 +35,13 @@ void matchHamcrestMatcher(Context context, Node actualNode, Matcher patternMatch
             if (!matcher.matches(value)) {
                 Description description = new StringDescription();
                 matcher.describeMismatch(value, description);
-                valueDifferenceReporter.differenceFound(context, "Matcher \"%s\" does not match value %s in node \"%s\". %s", matcherName, quoteTextValue(actualNode), context.actualPath(), description);
+                valueDifferenceReporter.differenceFound(
+                        context,
+                        "Matcher \"%s\" does not match value %s in node \"%s\". %s",
+                        matcherName,
+                        quoteTextValue(actualNode),
+                        context.actualPath(),
+                        description);
             }
         } else {
             structureDifferenceReporter.differenceFound(context, "Matcher \"%s\" not found.", matcherName);
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Jackson2NodeFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Jackson2NodeFactory.java
index f6544dbfe..74032d186 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Jackson2NodeFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Jackson2NodeFactory.java
@@ -15,28 +15,28 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
+
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
 import com.fasterxml.jackson.databind.node.NullNode;
-import net.javacrumbs.jsonunit.providers.Jackson2ObjectMapperProvider;
-
 import java.io.IOException;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.ServiceLoader;
-
-import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
+import net.javacrumbs.jsonunit.providers.Jackson2ObjectMapperProvider;
 
 /**
  * Deserializes node using Jackson 2
  */
 class Jackson2NodeFactory extends AbstractNodeFactory {
-    private final ServiceLoader<Jackson2ObjectMapperProvider> serviceLoader = ServiceLoader.load(Jackson2ObjectMapperProvider.class);
+    private final ServiceLoader<Jackson2ObjectMapperProvider> serviceLoader =
+            ServiceLoader.load(Jackson2ObjectMapperProvider.class);
 
     @Override
     protected Node doConvertValue(Object source) {
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JohnzonNodeFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JohnzonNodeFactory.java
index 9eb821d04..650f65668 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JohnzonNodeFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JohnzonNodeFactory.java
@@ -15,10 +15,15 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.apache.johnzon.core.JsonLongImpl;
-import org.apache.johnzon.mapper.Mapper;
-import org.apache.johnzon.mapper.MapperBuilder;
+import static java.util.Arrays.asList;
+import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toBoolList;
+import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toDoubleList;
+import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toIntList;
 
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.util.Iterator;
+import java.util.Map;
 import javax.json.Json;
 import javax.json.JsonArray;
 import javax.json.JsonNumber;
@@ -27,15 +32,9 @@
 import javax.json.JsonString;
 import javax.json.JsonValue;
 import javax.json.stream.JsonParsingException;
-import java.io.Reader;
-import java.math.BigDecimal;
-import java.util.Iterator;
-import java.util.Map;
-
-import static java.util.Arrays.asList;
-import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toBoolList;
-import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toDoubleList;
-import static net.javacrumbs.jsonunit.core.internal.ArrayUtils.toIntList;
+import org.apache.johnzon.core.JsonLongImpl;
+import org.apache.johnzon.mapper.Mapper;
+import org.apache.johnzon.mapper.MapperBuilder;
 
 public class JohnzonNodeFactory extends AbstractNodeFactory {
 
@@ -99,8 +98,7 @@ public Node element(int index) {
             if (jsonNode instanceof JsonArray) {
                 try {
                     return newNode(((JsonArray) jsonNode).get(index));
-                }
-                catch (IndexOutOfBoundsException e) {
+                } catch (IndexOutOfBoundsException e) {
                     return MISSING_NODE;
                 }
             } else {
@@ -111,7 +109,8 @@ public Node element(int index) {
         @Override
         public Iterator<KeyValue> fields() {
             if (jsonNode instanceof JsonObject) {
-                final Iterator<Map.Entry<String, JsonValue>> iterator = ((JsonObject) jsonNode).entrySet().iterator();
+                final Iterator<Map.Entry<String, JsonValue>> iterator =
+                        ((JsonObject) jsonNode).entrySet().iterator();
                 return new Iterator<>() {
                     @Override
                     public boolean hasNext() {
@@ -203,10 +202,8 @@ public NodeType getNodeType() {
 
         @Override
         public String asText() {
-            if (jsonNode.getValueType() == JsonValue.ValueType.STRING)
-                return ((JsonString) jsonNode).getString();
-            else
-                throw new IllegalStateException("Not a JsonString: " + jsonNode);
+            if (jsonNode.getValueType() == JsonValue.ValueType.STRING) return ((JsonString) jsonNode).getString();
+            else throw new IllegalStateException("Not a JsonString: " + jsonNode);
         }
 
         @Override
@@ -229,12 +226,9 @@ private boolean isNumber() {
 
         @Override
         public Boolean asBoolean() {
-            if (jsonNode.getValueType() == JsonValue.ValueType.TRUE)
-                return true;
-            else if (jsonNode.getValueType() == JsonValue.ValueType.FALSE)
-                return false;
-            else
-                throw new IllegalStateException("Not a JsonBoolean: " + jsonNode);
+            if (jsonNode.getValueType() == JsonValue.ValueType.TRUE) return true;
+            else if (jsonNode.getValueType() == JsonValue.ValueType.FALSE) return false;
+            else throw new IllegalStateException("Not a JsonBoolean: " + jsonNode);
         }
 
         @Override
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonOrgNodeFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonOrgNodeFactory.java
index 9403bb614..bc9d77719 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonOrgNodeFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonOrgNodeFactory.java
@@ -15,18 +15,17 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import net.javacrumbs.jsonunit.core.internal.GenericNodeBuilder.NodeSkeleton;
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-import org.json.JSONTokener;
+import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
 
 import java.io.Reader;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Map;
-
-import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
+import net.javacrumbs.jsonunit.core.internal.GenericNodeBuilder.NodeSkeleton;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
 
 /**
  * Deserializes node using org.json.JSONObject
@@ -188,5 +187,4 @@ public String toString() {
             return jsonObject.toString();
         }
     }
-
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonSource.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonSource.java
index cccff6461..e3b29564a 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonSource.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonSource.java
@@ -27,5 +27,3 @@ public interface JsonSource {
 
     List<String> getMatchingPaths();
 }
-
-
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonUtils.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonUtils.java
index a084b7834..1aaca7ca3 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonUtils.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/JsonUtils.java
@@ -15,19 +15,17 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-
-import net.javacrumbs.jsonunit.core.Configuration;
-import net.javacrumbs.jsonunit.core.Option;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import static java.util.Collections.emptyList;
+import static java.util.Map.Entry.comparingByKey;
 
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-
-import static java.util.Collections.emptyList;
-import static java.util.Map.Entry.comparingByKey;
+import net.javacrumbs.jsonunit.core.Configuration;
+import net.javacrumbs.jsonunit.core.Option;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Internal utility class to parse JSON values.
@@ -35,7 +33,6 @@
 public class JsonUtils {
     private static final Converter converter = Converter.createDefaultConverter();
 
-
     /**
      * Converts object to JSON.
      *
@@ -58,7 +55,6 @@ public static Node convertToJson(@Nullable Object source, String label, boolean
         }
     }
 
-
     /**
      * Converts value to Json node. It can be Map, String, null, or primitive. Should not be parsed, just converted.
      */
@@ -80,12 +76,12 @@ public static Node getNode(Object root, String path) {
     }
 
     /**
-      * Returns node with given path.
-      */
-     @NotNull
-     public static Node getNode(Object root, Path path) {
-         return path.getNode(convertToJson(root, "actual"));
-     }
+     * Returns node with given path.
+     */
+    @NotNull
+    public static Node getNode(Object root, Path path) {
+        return path.getNode(convertToJson(root, "actual"));
+    }
 
     public static boolean nodeAbsent(Object json, String path, Configuration configuration) {
         return nodeAbsent(json, Path.create(path), configuration);
@@ -126,7 +122,6 @@ static boolean nodeAbsent(Object json, Path path, boolean treatNullAsAbsent) {
         }
     }
 
-
     /**
      * Add quotes around the object iff it's not a JSON object.
      *
@@ -136,9 +131,12 @@ static boolean nodeAbsent(Object json, Path path, boolean treatNullAsAbsent) {
     static String quoteIfNeeded(String source) {
         String trimmed = source.trim();
 
-        if (isObject(trimmed) || isArray(trimmed) || isString(trimmed)
-            || isBoolean(trimmed) || isNull(trimmed)
-            || isNumber(trimmed)) {
+        if (isObject(trimmed)
+                || isArray(trimmed)
+                || isString(trimmed)
+                || isBoolean(trimmed)
+                || isNull(trimmed)
+                || isNumber(trimmed)) {
             return source;
         } else {
             return "\"" + source + "\"";
@@ -202,7 +200,8 @@ private static boolean isNumber(String source) {
     static String prettyPrint(Map<String, Object> map) {
         StringBuilder builder = new StringBuilder();
         builder.append("{");
-        Iterator<Entry<String, Object>> entries = map.entrySet().stream().sorted(comparingByKey()).iterator();
+        Iterator<Entry<String, Object>> entries =
+                map.entrySet().stream().sorted(comparingByKey()).iterator();
         while (entries.hasNext()) {
             Entry<String, Object> entry = entries.next();
             builder.append('"').append(entry.getKey()).append('"').append(":");
@@ -251,7 +250,7 @@ public List<String> getMatchingPaths() {
 
         @Override
         public String toString() {
-            return "JSON in path \"" + pathPrefix +"\"";
+            return "JSON in path \"" + pathPrefix + "\"";
         }
     }
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/MoshiNodeFactory.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/MoshiNodeFactory.java
index 6ea409188..a06bd0ce0 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/MoshiNodeFactory.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/MoshiNodeFactory.java
@@ -15,17 +15,16 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
+import static net.javacrumbs.jsonunit.core.internal.Utils.toReader;
+
 import com.squareup.moshi.JsonAdapter;
 import com.squareup.moshi.Moshi;
-
 import java.io.IOException;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 
-import static net.javacrumbs.jsonunit.core.internal.Utils.closeQuietly;
-import static net.javacrumbs.jsonunit.core.internal.Utils.toReader;
-
 /**
  * Deserializes node using Moshi
  */
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Node.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Node.java
index a400b9b55..9d1fdcf20 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Node.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Node.java
@@ -15,15 +15,14 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.prettyPrint;
+
 import java.math.BigDecimal;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
 
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.prettyPrint;
-
-
 /**
  * For internal use only!!! Abstract node representation.
  */
@@ -210,6 +209,7 @@ public String toString() {
             return "<missing>";
         }
     };
+
     interface ValueExtractor {
         Object getValue(Node node);
     }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/NodeWrapper.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/NodeWrapper.java
index 4eb4729f4..1dbf5a985 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/NodeWrapper.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/NodeWrapper.java
@@ -82,7 +82,5 @@ default Object getValue() {
     }
 
     @Override
-    default void ___do_not_implement_this_interface_seriously() {
-
-    }
+    default void ___do_not_implement_this_interface_seriously() {}
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Path.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Path.java
index c1ba8ff8d..bfebea3d5 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Path.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Path.java
@@ -35,8 +35,8 @@ private Path(String path, String pathPrefix) {
     }
 
     public static Path root() {
-          return create("", "");
-      }
+        return create("", "");
+    }
 
     public static Path create(String path) {
         return create(path, "");
@@ -63,7 +63,7 @@ String getFullPath() {
             return path;
         } else if (path.startsWith("[")) {
             return pathPrefix + path;
-        } else if (!path.isEmpty()){
+        } else if (!path.isEmpty()) {
             return pathPrefix + "." + path;
         } else {
             return pathPrefix;
@@ -96,7 +96,7 @@ Path length() {
     }
 
     public Path to(String name) {
-        if (name.startsWith("[")){
+        if (name.startsWith("[")) {
             return copy(path + name);
         } else {
             return toField(name);
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathMatcher.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathMatcher.java
index aa1d4eacd..b7b1ae1c3 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathMatcher.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathMatcher.java
@@ -15,12 +15,12 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static java.util.stream.Collectors.toList;
+
 import java.util.Collection;
 import java.util.List;
 import java.util.regex.Pattern;
 
-import static java.util.stream.Collectors.toList;
-
 abstract class PathMatcher {
     private static final PathMatcher EMPTY = new PathMatcher() {
         @Override
@@ -71,19 +71,12 @@ private static class ArrayWildcardMatcher extends PathMatcher {
             int from = 0;
             int to;
             while ((to = path.indexOf("[*]", from)) >= 0) {
-                regexp
-                    .append("\\Q")
-                    .append(path, from, to)
-                    .append("\\E")
-                    .append("\\[\\d+\\]");
+                regexp.append("\\Q").append(path, from, to).append("\\E").append("\\[\\d+\\]");
                 from = to + 3; // length of the placeholder [*]
             }
             // End of the pattern if any
             if (from < path.length()) {
-                regexp
-                    .append("\\Q")
-                    .append(path.substring(from))
-                    .append("\\E");
+                regexp.append("\\Q").append(path.substring(from)).append("\\E");
             }
             pattern = Pattern.compile(regexp.toString());
         }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOption.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOption.java
index cec6380c9..52271934b 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOption.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOption.java
@@ -1,12 +1,10 @@
 package net.javacrumbs.jsonunit.core.internal;
 
-
-import net.javacrumbs.jsonunit.core.Option;
-
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Set;
+import net.javacrumbs.jsonunit.core.Option;
 
 public class PathOption {
     private final List<String> paths;
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOptionMatcher.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOptionMatcher.java
index c66ff20cc..2a9ee3fde 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOptionMatcher.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/PathOptionMatcher.java
@@ -1,10 +1,8 @@
 package net.javacrumbs.jsonunit.core.internal;
 
-
-import net.javacrumbs.jsonunit.core.Option;
-
 import java.util.Collection;
 import java.util.stream.Stream;
+import net.javacrumbs.jsonunit.core.Option;
 
 class PathOptionMatcher {
     private final PathMatcher pathMatcher;
@@ -23,7 +21,7 @@ private PathOptionMatcher(Collection<String> paths, Option option, boolean added
 
     static Stream<PathOptionMatcher> createMatchersFromPathOption(PathOption pathOption) {
         return pathOption.getOptions().stream()
-            .map(option -> new PathOptionMatcher(pathOption.getPaths(), option, pathOption.isIncluded()));
+                .map(option -> new PathOptionMatcher(pathOption.getPaths(), option, pathOption.isIncluded()));
     }
 
     public boolean matches(String path) {
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Utils.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Utils.java
index 1cc40951d..31829c603 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Utils.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/Utils.java
@@ -15,11 +15,10 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.jetbrains.annotations.NotNull;
-
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * Resource reading utility
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/matchers/InternalMatcher.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/matchers/InternalMatcher.java
index b2c7f4410..935034001 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/matchers/InternalMatcher.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/internal/matchers/InternalMatcher.java
@@ -15,24 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.internal.matchers;
 
-import net.javacrumbs.jsonunit.core.Configuration;
-import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
-import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
-import net.javacrumbs.jsonunit.core.Option;
-import net.javacrumbs.jsonunit.core.internal.Diff;
-import net.javacrumbs.jsonunit.core.internal.JsonSource;
-import net.javacrumbs.jsonunit.core.internal.Node;
-import net.javacrumbs.jsonunit.core.internal.Path;
-import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
-import org.hamcrest.Matcher;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
 import static java.util.Collections.singletonList;
 import static net.javacrumbs.jsonunit.core.internal.Diff.create;
 import static net.javacrumbs.jsonunit.core.internal.Diff.quoteTextValue;
@@ -45,6 +27,22 @@
 import static net.javacrumbs.jsonunit.core.internal.Node.NodeType.STRING;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import net.javacrumbs.jsonunit.core.Configuration;
+import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
+import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
+import net.javacrumbs.jsonunit.core.Option;
+import net.javacrumbs.jsonunit.core.internal.Diff;
+import net.javacrumbs.jsonunit.core.internal.JsonSource;
+import net.javacrumbs.jsonunit.core.internal.Node;
+import net.javacrumbs.jsonunit.core.internal.Path;
+import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
+import org.hamcrest.Matcher;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Internal class, please do not use outside the library
@@ -58,7 +56,12 @@ public final class InternalMatcher {
     private final Configuration configuration;
     private final String nodeDescription;
 
-    public InternalMatcher(@Nullable Object actual, @NotNull Path path, @NotNull String description, @NotNull Configuration configuration, @NotNull String nodeDescription) {
+    public InternalMatcher(
+            @Nullable Object actual,
+            @NotNull Path path,
+            @NotNull String description,
+            @NotNull Configuration configuration,
+            @NotNull String nodeDescription) {
         this.path = path;
         this.actual = actual;
         this.description = description;
@@ -66,7 +69,11 @@ public InternalMatcher(@Nullable Object actual, @NotNull Path path, @NotNull Str
         this.nodeDescription = nodeDescription;
     }
 
-    public InternalMatcher(@Nullable Object actual, @NotNull Path path, @NotNull String description, @NotNull Configuration configuration) {
+    public InternalMatcher(
+            @Nullable Object actual,
+            @NotNull Path path,
+            @NotNull String description,
+            @NotNull Configuration configuration) {
         this(actual, path, description, configuration, "Node \"" + path + "\"");
     }
 
@@ -114,7 +121,6 @@ public InternalMatcher withTolerance(@Nullable BigDecimal tolerance) {
         return new InternalMatcher(actual, path, description, configuration.withTolerance(tolerance));
     }
 
-
     /**
      * Adds a internalMatcher to be used in ${json-unit.matches:matcherName} macro.
      */
@@ -155,13 +161,11 @@ public final InternalMatcher when(@NotNull PathsParam object, @NotNull Applicabl
         return new InternalMatcher(actual, path, description, configuration.when(object, actions));
     }
 
-
     public void isEqualTo(@Nullable Object expected) {
         Diff diff = createDiff(expected, configuration);
         diff.failIfDifferent(description);
     }
 
-
     /**
      * Fails if the selected JSON is not a String or is not present or the value
      * is not equal to expected value.
@@ -188,7 +192,8 @@ private void failOnDifference(@Nullable Object expected, @NotNull Object actual,
             path = paths.toString();
             node = "nodes";
         }
-        failWithMessage(String.format("Different value found in %s \"%s\", expected: <%s> but was: <%s>.", node, path, expected, actual));
+        failWithMessage(String.format(
+                "Different value found in %s \"%s\", expected: <%s> but was: <%s>.", node, path, expected, actual));
     }
 
     /**
@@ -230,7 +235,6 @@ private void failWithMessage(@NotNull String message) {
         }
     }
 
-
     /**
      * Fails if the node exists.
      */
@@ -337,7 +341,8 @@ public void failOnType(@NotNull Node node, @NotNull String expectedType) {
     }
 
     private void failOnType(@NotNull String expectedType, @Nullable Object actualType) {
-        failWithMessage(nodeDescription + " has invalid type, expected: <" + expectedType + "> but was: <" + actualType + ">.");
+        failWithMessage(
+                nodeDescription + " has invalid type, expected: <" + expectedType + "> but was: <" + actualType + ">.");
     }
 
     /**
@@ -360,7 +365,6 @@ private void match(@NotNull Object value, @NotNull Path path, @NotNull Matcher<?
         assertThat(nodeDescription + " does not match.", node.getValue(), (Matcher<? super Object>) matcher);
     }
 
-
     /**
      * Array assertions
      */
@@ -380,7 +384,8 @@ public class ArrayMatcher {
          */
         public void ofLength(int expectedLength) {
             if (array.size() != expectedLength) {
-                failWithMessage(nodeDescription + " has invalid length, expected: <" + expectedLength + "> but was: <" + array.size() + ">.");
+                failWithMessage(nodeDescription + " has invalid length, expected: <" + expectedLength + "> but was: <"
+                        + array.size() + ">.");
             }
         }
 
@@ -407,6 +412,5 @@ public void isNotEmpty() {
                 failWithMessage(nodeDescription + " is an empty array.");
             }
         }
-
     }
 }
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/Difference.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/Difference.java
index 588c2fbd3..f7c841624 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/Difference.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/Difference.java
@@ -19,7 +19,11 @@
  * Describes differences between documents.
  */
 public interface Difference {
-    enum Type {EXTRA, MISSING, DIFFERENT}
+    enum Type {
+        EXTRA,
+        MISSING,
+        DIFFERENT
+    }
 
     /**
      * Path to the difference
@@ -36,7 +40,6 @@ enum Type {EXTRA, MISSING, DIFFERENT}
      */
     Object getActual();
 
-
     /**
      * Expected node serialized as Map&lt;String, Object&gt; for objects, BigDecimal for numbers, ...
      */
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceContext.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceContext.java
index 4baddbfa6..74b1247e6 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceContext.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceContext.java
@@ -29,7 +29,6 @@ public interface DifferenceContext {
      */
     Object getActualSource();
 
-
     /**
      * Expected source serialized as Map&lt;String, Object&gt; for objects, BigDecimal for numbers, ...
      */
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceListener.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceListener.java
index 72884a614..2344e85f0 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceListener.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/listener/DifferenceListener.java
@@ -15,7 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.listener;
 
-
 /**
  * Can listen on differences between documents.
  */
diff --git a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/util/ResourceUtils.java b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/util/ResourceUtils.java
index 4254930af..407ae3770 100644
--- a/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/util/ResourceUtils.java
+++ b/json-unit-core/src/main/java/net/javacrumbs/jsonunit/core/util/ResourceUtils.java
@@ -15,6 +15,9 @@
  */
 package net.javacrumbs.jsonunit.core.util;
 
+import static java.lang.String.format;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
@@ -22,9 +25,6 @@
 import java.io.Reader;
 import java.util.Objects;
 
-import static java.lang.String.format;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
 /**
  * Resource reading utility
  */
diff --git a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/ConverterTest.java b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/ConverterTest.java
index 7078ee086..42c3e103a 100644
--- a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/ConverterTest.java
+++ b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/ConverterTest.java
@@ -15,12 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import com.fasterxml.jackson.databind.node.BooleanNode;
-import org.junit.jupiter.api.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-
 import static net.javacrumbs.jsonunit.core.internal.ClassUtils.isClassPresent;
 import static net.javacrumbs.jsonunit.core.internal.Converter.LIBRARIES_PROPERTY_NAME;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -30,6 +24,11 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import com.fasterxml.jackson.databind.node.BooleanNode;
+import java.util.Arrays;
+import java.util.Collections;
+import org.junit.jupiter.api.Test;
+
 class ConverterTest {
 
     private static final String JSON = "{\"test\":1}";
@@ -53,10 +52,9 @@ void shouldUsePreferredFactory() {
         assertEquals(Jackson2NodeFactory.Jackson2Node.class, node.getClass());
     }
 
-
     @Test
     void shouldUseOnlyFactorySpecifiedBySystemProperty() {
-        System.setProperty(LIBRARIES_PROPERTY_NAME,"gson");
+        System.setProperty(LIBRARIES_PROPERTY_NAME, "gson");
         Converter converter = Converter.createDefaultConverter();
         assertThat(converter.factories()).extracting("class").containsExactly(GsonNodeFactory.class);
         System.setProperty(LIBRARIES_PROPERTY_NAME, "");
@@ -64,15 +62,17 @@ void shouldUseOnlyFactorySpecifiedBySystemProperty() {
 
     @Test
     void shouldChangeOrderSpecifiedBySystemProperty() {
-        System.setProperty(LIBRARIES_PROPERTY_NAME,"jackson2, gson ,json.org");
+        System.setProperty(LIBRARIES_PROPERTY_NAME, "jackson2, gson ,json.org");
         Converter converter = Converter.createDefaultConverter();
-        assertThat(converter.factories()).extracting("class").containsExactly(Jackson2NodeFactory.class, GsonNodeFactory.class, JsonOrgNodeFactory.class);
+        assertThat(converter.factories())
+                .extracting("class")
+                .containsExactly(Jackson2NodeFactory.class, GsonNodeFactory.class, JsonOrgNodeFactory.class);
         System.setProperty(LIBRARIES_PROPERTY_NAME, "");
     }
 
     @Test
     void shouldFailOnUnknownFactory() {
-        System.setProperty(LIBRARIES_PROPERTY_NAME,"unknown");
+        System.setProperty(LIBRARIES_PROPERTY_NAME, "unknown");
         try {
             Converter.createDefaultConverter();
             fail("Exception expected");
diff --git a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/DifferenceTest.java b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/DifferenceTest.java
index 70150e10c..bbfcd3c0d 100644
--- a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/DifferenceTest.java
+++ b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/DifferenceTest.java
@@ -15,6 +15,17 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
+import static java.math.BigDecimal.valueOf;
+import static java.util.Collections.singletonMap;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.Option;
 import net.javacrumbs.jsonunit.core.ParametrizedMatcher;
@@ -25,18 +36,6 @@
 import org.hamcrest.Description;
 import org.junit.jupiter.api.Test;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-
-import static java.math.BigDecimal.valueOf;
-import static java.util.Collections.singletonMap;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 public class DifferenceTest {
     private final RecordingDifferenceListener listener = new RecordingDifferenceListener();
 
@@ -178,7 +177,8 @@ void shouldSeeAddedArrayNode() {
 
     @Test
     void shouldSeeObjectDiffNodes() {
-        Diff diff = Diff.create("{\"test\": { \"test1\": \"1\"}}", "{\"test\": { \"test1\": \"2\"} }", "", "", commonConfig());
+        Diff diff = Diff.create(
+                "{\"test\": { \"test1\": \"1\"}}", "{\"test\": { \"test1\": \"2\"} }", "", "", commonConfig());
         diff.similar();
         assertThat(listener.getDifferenceList(), hasSize(1));
         assertThat(listener.getDifferenceList().get(0).getType(), equalTo(DifferenceImpl.Type.DIFFERENT));
@@ -196,7 +196,12 @@ void shouldSeeNullNode() {
 
     @Test
     void shouldWorkWhenIgnoringArrayOrder() {
-        Diff diff = Diff.create("{\"test\": [[1,2],[2,3]]}", "{\"test\":[[4,2],[1,2]]}", "", "", commonConfig().when(Option.IGNORING_ARRAY_ORDER));
+        Diff diff = Diff.create(
+                "{\"test\": [[1,2],[2,3]]}",
+                "{\"test\":[[4,2],[1,2]]}",
+                "",
+                "",
+                commonConfig().when(Option.IGNORING_ARRAY_ORDER));
         diff.similar();
         assertThat(listener.getDifferenceList(), hasSize(1));
         assertThat(listener.getDifferenceList().get(0).getType(), equalTo(DifferenceImpl.Type.DIFFERENT));
@@ -222,8 +227,13 @@ void shouldSeeExpectedSource() {
 
     @Test
     void shouldMatchWithLineSeparatorCustomMatcher() {
-        Configuration cfg = commonConfig().withMatcher("equalTo",  new EqualsMatcher());
-        Diff diff = Diff.create("{\"key\": \"${json-unit.matches:equalTo}separated \\n line\"}", "{\"key\": \"separated \\n line\"}", "", "", cfg);
+        Configuration cfg = commonConfig().withMatcher("equalTo", new EqualsMatcher());
+        Diff diff = Diff.create(
+                "{\"key\": \"${json-unit.matches:equalTo}separated \\n line\"}",
+                "{\"key\": \"separated \\n line\"}",
+                "",
+                "",
+                cfg);
         assertTrue(diff.similar());
         assertThat(listener.getDifferenceList(), hasSize(0));
     }
diff --git a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/JsonUtilsTest.java b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/JsonUtilsTest.java
index 238e9af81..79cb03e29 100644
--- a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/JsonUtilsTest.java
+++ b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/JsonUtilsTest.java
@@ -15,12 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.Test;
-
-import java.io.IOException;
-import java.math.BigDecimal;
-
 import static java.util.Collections.singletonMap;
 import static net.javacrumbs.jsonunit.core.internal.JsonUtils.convertToJson;
 import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getNode;
@@ -37,6 +31,11 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.math.BigDecimal;
+import org.junit.jupiter.api.Test;
+
 class JsonUtilsTest {
 
     private static final ObjectMapper mapper = new ObjectMapper();
@@ -66,7 +65,7 @@ void testValueToJson() {
         assertEquals(NUMBER, valueToNode(1.0).getNodeType());
         assertEquals(STRING, valueToNode("1.0").getNodeType());
         assertEquals(OBJECT, valueToNode(singletonMap("a", 1)).getNodeType());
-        assertEquals(ARRAY, valueToNode(new int[]{1 ,2, 3}).getNodeType());
+        assertEquals(ARRAY, valueToNode(new int[] {1, 2, 3}).getNodeType());
         assertEquals(STRING, valueToNode("true").getNodeType());
         assertEquals(BOOLEAN, valueToNode(true).getNodeType());
         assertEquals(STRING, valueToNode("false").getNodeType());
@@ -85,7 +84,6 @@ void testQuoteIfNeeded() {
         assertEquals("false", quoteIfNeeded("false"));
         assertEquals("null", quoteIfNeeded("null"));
 
-
         assertEquals("\"a\"", quoteIfNeeded("a"));
         assertEquals("\"a b\"", quoteIfNeeded("a b"));
         assertEquals("\"123 b\"", quoteIfNeeded("123 b"));
@@ -123,7 +121,8 @@ void testGetStartNodeArraysNegated() throws IOException {
 
     @Test
     void testGetStartNodeArrays2() throws IOException {
-        Node startNode = getNode(mapper.readTree("{\"test\":[{\"values\":[1,2]}, {\"values\":[3,4]}]}"), "test[1].values[1]");
+        Node startNode =
+                getNode(mapper.readTree("{\"test\":[{\"values\":[1,2]}, {\"values\":[3,4]}]}"), "test[1].values[1]");
         assertEquals(4, startNode.decimalValue().intValue());
     }
 
@@ -135,7 +134,8 @@ void testGetStartNodeArraysRootComplex() throws IOException {
 
     @Test
     void testGetStartNodeArraysConvoluted() throws IOException {
-        Node startNode = getNode(mapper.readTree("{\"test\":[{\"values\":[1,2]}, {\"values\":[3,4]}]}"), "test.[1].values.[1]");
+        Node startNode =
+                getNode(mapper.readTree("{\"test\":[{\"values\":[1,2]}, {\"values\":[3,4]}]}"), "test.[1].values.[1]");
         assertEquals(4, startNode.decimalValue().intValue());
     }
 
diff --git a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/NodeFactoryTest.java b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/NodeFactoryTest.java
index d4e44afd3..593c5f0f7 100644
--- a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/NodeFactoryTest.java
+++ b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/NodeFactoryTest.java
@@ -15,15 +15,6 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Iterator;
-
 import static java.math.BigDecimal.ONE;
 import static java.math.BigDecimal.valueOf;
 import static java.util.Arrays.asList;
@@ -32,6 +23,14 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
 @RunWith(Parameterized.class)
 public class NodeFactoryTest {
 
@@ -43,11 +42,8 @@ public NodeFactoryTest(AbstractNodeFactory factory) {
 
     @Parameters
     public static Collection<Object[]> data() {
-        return Arrays.asList(new Object[][]{
-            {new JsonOrgNodeFactory()},
-            {new Jackson2NodeFactory()},
-            {new GsonNodeFactory()},
-            {new MoshiNodeFactory()},
+        return Arrays.asList(new Object[][] {
+            {new JsonOrgNodeFactory()}, {new Jackson2NodeFactory()}, {new GsonNodeFactory()}, {new MoshiNodeFactory()},
         });
     }
 
@@ -116,7 +112,7 @@ public void shouldParseObject() {
 
     @Test
     public void shouldConvertArray() {
-        Node node = factory.convertValue(new int[]{1, 2});
+        Node node = factory.convertValue(new int[] {1, 2});
         assertEquals(Node.NodeType.ARRAY, node.getNodeType());
         assertEquals(ONE, node.element(0).decimalValue());
     }
@@ -132,5 +128,4 @@ public void shouldConvertCollection() {
     private Node read(String value) {
         return factory.readValue(toReader(value), "label", false);
     }
-
 }
diff --git a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/PathMatcherTest.java b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/PathMatcherTest.java
index 3ca6f6d18..357cf2d01 100644
--- a/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/PathMatcherTest.java
+++ b/json-unit-core/src/test/java/net/javacrumbs/jsonunit/core/internal/PathMatcherTest.java
@@ -15,11 +15,10 @@
  */
 package net.javacrumbs.jsonunit.core.internal;
 
-import org.junit.jupiter.api.Test;
-
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import org.junit.jupiter.api.Test;
 
 class PathMatcherTest {
 
diff --git a/json-unit-fluent/src/main/java/net/javacrumbs/jsonunit/fluent/JsonFluentAssert.java b/json-unit-fluent/src/main/java/net/javacrumbs/jsonunit/fluent/JsonFluentAssert.java
index 8251190a9..f717f75a0 100644
--- a/json-unit-fluent/src/main/java/net/javacrumbs/jsonunit/fluent/JsonFluentAssert.java
+++ b/json-unit-fluent/src/main/java/net/javacrumbs/jsonunit/fluent/JsonFluentAssert.java
@@ -15,6 +15,11 @@
  */
 package net.javacrumbs.jsonunit.fluent;
 
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.convertToJson;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
+import static net.javacrumbs.jsonunit.core.internal.matchers.InternalMatcher.ACTUAL;
+
+import java.math.BigDecimal;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
@@ -25,13 +30,6 @@
 import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
 import org.hamcrest.Matcher;
 
-import java.math.BigDecimal;
-
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.convertToJson;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
-import static net.javacrumbs.jsonunit.core.internal.matchers.InternalMatcher.ACTUAL;
-
-
 /**
  * Contains JSON related fluent assertions inspired by FEST or AssertJ. Typical usage is:
  *
@@ -102,7 +100,6 @@ public JsonFluentAssert isEqualTo(Object expected) {
         return this;
     }
 
-
     /**
      * Fails if the selected JSON is not a String or is not present or the value
      * is not equal to expected value.
@@ -157,7 +154,6 @@ public JsonFluentAssert isPresent() {
         return this;
     }
 
-
     /**
      * Fails if the selected JSON is not an Array or is not present.
      *
@@ -168,7 +164,6 @@ public ArrayAssert isArray() {
         return new ArrayAssert(internalMatcher.isArray());
     }
 
-
     /**
      * Fails if the selected JSON is not an Object or is not present.
      */
@@ -200,7 +195,6 @@ public JsonFluentAssert matches(Matcher<?> matcher) {
         return this;
     }
 
-
     /**
      * Array assertions
      */
@@ -235,10 +229,8 @@ public ArrayAssert isNotEmpty() {
             arrayMatcher.isNotEmpty();
             return this;
         }
-
     }
 
-
     /**
      * JsonFluentAssert that can be configured. To make sure that configuration is done before comparison and not after.
      */
@@ -326,7 +318,6 @@ public ConfigurableJsonFluentAssert withTolerance(BigDecimal tolerance) {
             return new ConfigurableJsonFluentAssert(internalMatcher.withTolerance(tolerance));
         }
 
-
         /**
          * Adds a internalMatcher to be used in ${json-unit.matches:matcherName} macro.
          */
diff --git a/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtils.java b/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtils.java
index 41578f6c2..a7da335de 100644
--- a/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtils.java
+++ b/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtils.java
@@ -15,67 +15,63 @@
  */
 package net.javacrumbs.jsonunit.jsonpath;
 
+import static com.jayway.jsonpath.JsonPath.using;
+import static java.util.stream.Collectors.toList;
 
 import com.jayway.jsonpath.Option;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Stream;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.JsonUtils;
 import net.javacrumbs.jsonunit.core.internal.PathOption;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.stream.Stream;
-
-import static com.jayway.jsonpath.JsonPath.using;
-import static java.util.stream.Collectors.toList;
-
 public class InternalJsonPathUtils {
-    private InternalJsonPathUtils() {
-
-    }
+    private InternalJsonPathUtils() {}
 
     @NotNull
     public static Configuration resolveJsonPaths(@NotNull Object json, @NotNull Configuration configuration) {
         Collection<String> pathsToBeIgnored = resolveJsonPaths(json, configuration.getPathsToBeIgnored());
-        List<PathOption> pathOptions = configuration.getPathOptions()
-            .stream().map(po -> {
-                List<String> newPoPaths = resolveJsonPaths(json, po.getPaths());
-                return po.withPaths(newPoPaths);
-            }).collect(toList());
+        List<PathOption> pathOptions = configuration.getPathOptions().stream()
+                .map(po -> {
+                    List<String> newPoPaths = resolveJsonPaths(json, po.getPaths());
+                    return po.withPaths(newPoPaths);
+                })
+                .collect(toList());
 
-        return configuration
-            .whenIgnoringPaths(pathsToBeIgnored)
-            .withPathOptions(pathOptions);
+        return configuration.whenIgnoringPaths(pathsToBeIgnored).withPathOptions(pathOptions);
     }
 
     @NotNull
     private static List<String> resolveJsonPaths(@NotNull Object json, @NotNull Collection<String> paths) {
         com.jayway.jsonpath.Configuration conf = com.jayway.jsonpath.Configuration.builder()
-            .options(Option.AS_PATH_LIST, Option.SUPPRESS_EXCEPTIONS)
-            .build();
+                .options(Option.AS_PATH_LIST, Option.SUPPRESS_EXCEPTIONS)
+                .build();
 
-        return paths.stream().flatMap(path -> {
-            if (path.startsWith("$")) {
-                List<String> resolvedPaths = readValue(conf, json, path);
-                return resolvedPaths.stream().map(InternalJsonPathUtils::fromBracketNotation);
-            } else {
-                return Stream.of(path);
-            }
-        }).collect(toList());
+        return paths.stream()
+                .flatMap(path -> {
+                    if (path.startsWith("$")) {
+                        List<String> resolvedPaths = readValue(conf, json, path);
+                        return resolvedPaths.stream().map(InternalJsonPathUtils::fromBracketNotation);
+                    } else {
+                        return Stream.of(path);
+                    }
+                })
+                .collect(toList());
     }
 
     static <T> T readValue(com.jayway.jsonpath.Configuration conf, Object json, String path) {
         if (json instanceof String) {
             return using(conf).parse((String) json).read(path);
         } else {
-            return using(conf).parse(JsonUtils.convertToJson(json, "actual").getValue()).read(path);
+            return using(conf)
+                    .parse(JsonUtils.convertToJson(json, "actual").getValue())
+                    .read(path);
         }
     }
 
     static String fromBracketNotation(String path) {
-        return path
-            .replace("['", ".")
-            .replace("']", "");
+        return path.replace("['", ".").replace("']", "");
     }
-
 }
diff --git a/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/JsonPathAdapter.java b/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/JsonPathAdapter.java
index 3ea1ad31d..73257db2a 100644
--- a/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/JsonPathAdapter.java
+++ b/json-unit-json-path/src/main/java/net/javacrumbs/jsonunit/jsonpath/JsonPathAdapter.java
@@ -15,14 +15,6 @@
  */
 package net.javacrumbs.jsonunit.jsonpath;
 
-import com.jayway.jsonpath.EvaluationListener;
-import com.jayway.jsonpath.PathNotFoundException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-
 import static com.jayway.jsonpath.Configuration.defaultConfiguration;
 import static net.javacrumbs.jsonunit.core.internal.JsonUtils.jsonSource;
 import static net.javacrumbs.jsonunit.core.internal.JsonUtils.missingNode;
@@ -30,13 +22,18 @@
 import static net.javacrumbs.jsonunit.jsonpath.InternalJsonPathUtils.fromBracketNotation;
 import static net.javacrumbs.jsonunit.jsonpath.InternalJsonPathUtils.readValue;
 
+import com.jayway.jsonpath.EvaluationListener;
+import com.jayway.jsonpath.PathNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
 /**
  * Adapts json-path to json-unit.
  */
 public final class JsonPathAdapter {
-    private JsonPathAdapter() {
-
-    }
+    private JsonPathAdapter() {}
 
     @NotNull
     public static Object inPath(@Nullable Object json, @NotNull String path) {
diff --git a/json-unit-json-path/src/test/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtilsTest.java b/json-unit-json-path/src/test/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtilsTest.java
index cbf4b0ac2..43bd21fe7 100644
--- a/json-unit-json-path/src/test/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtilsTest.java
+++ b/json-unit-json-path/src/test/java/net/javacrumbs/jsonunit/jsonpath/InternalJsonPathUtilsTest.java
@@ -1,11 +1,10 @@
 package net.javacrumbs.jsonunit.jsonpath;
 
-import org.junit.jupiter.api.Test;
-
-
 import static net.javacrumbs.jsonunit.jsonpath.InternalJsonPathUtils.fromBracketNotation;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import org.junit.jupiter.api.Test;
+
 class InternalJsonPathUtilsTest {
 
     @Test
@@ -14,5 +13,4 @@ void shouldConvertFromBracketNotation() {
         assertThat(fromBracketNotation("$['tool'][2]['jsonpath']")).isEqualTo("$.tool[2].jsonpath");
         assertThat(fromBracketNotation("$[0][0]")).isEqualTo("$[0][0]");
     }
-
-}
\ No newline at end of file
+}
diff --git a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatcher.java b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatcher.java
index 82cf0ce71..b78e1c19d 100644
--- a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatcher.java
+++ b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatcher.java
@@ -15,19 +15,21 @@
  */
 package net.javacrumbs.jsonunit.spring;
 
+import java.util.function.BiConsumer;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.Path;
 import net.javacrumbs.jsonunit.core.internal.matchers.InternalMatcher;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.function.BiConsumer;
-
 abstract class AbstractSpringMatcher {
     private final Path path;
     private final Configuration configuration;
     private final BiConsumer<Object, InternalMatcher> matcher;
 
-    AbstractSpringMatcher(@NotNull Path path, @NotNull Configuration configuration, @NotNull BiConsumer<Object, InternalMatcher> matcher) {
+    AbstractSpringMatcher(
+            @NotNull Path path,
+            @NotNull Configuration configuration,
+            @NotNull BiConsumer<Object, InternalMatcher> matcher) {
         this.path = path;
         this.configuration = configuration;
         this.matcher = matcher;
diff --git a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatchers.java b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatchers.java
index 53855f683..cbe6017b8 100644
--- a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatchers.java
+++ b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/AbstractSpringMatchers.java
@@ -15,6 +15,8 @@
  */
 package net.javacrumbs.jsonunit.spring;
 
+import java.math.BigDecimal;
+import java.util.function.BiConsumer;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.Option;
 import net.javacrumbs.jsonunit.core.internal.Path;
@@ -24,10 +26,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.math.BigDecimal;
-import java.util.function.BiConsumer;
-
-
 /**
  * Common superclass for request and response matcher
  * @param <ME> Type of the factory class
@@ -42,7 +40,6 @@ abstract class AbstractSpringMatchers<ME, MATCHER> {
         this.configuration = configuration;
     }
 
-
     @NotNull
     abstract MATCHER matcher(@NotNull BiConsumer<Object, InternalMatcher> matcher);
 
@@ -65,7 +62,6 @@ public ME node(String newPath) {
         return matchers(path.copy(newPath), configuration);
     }
 
-
     /**
      * Sets the placeholder that can be used to ignore values.
      * The default value is ${json-unit.ignore}
@@ -143,7 +139,7 @@ public MATCHER isEqualTo(@Nullable Object expected) {
      * is not equal to expected value.
      */
     @NotNull
-    public MATCHER isStringEqualTo(@Nullable  final String expected) {
+    public MATCHER isStringEqualTo(@Nullable final String expected) {
         return matcher((actual, ctx) -> ctx.isStringEqualTo(expected));
     }
 
@@ -244,5 +240,4 @@ public MATCHER isTrue() {
     public MATCHER isFalse() {
         return isEqualTo(false);
     }
-
 }
diff --git a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitRequestMatchers.java b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitRequestMatchers.java
index ee047441a..5314ac0d9 100644
--- a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitRequestMatchers.java
+++ b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitRequestMatchers.java
@@ -15,6 +15,7 @@
  */
 package net.javacrumbs.jsonunit.spring;
 
+import java.util.function.BiConsumer;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.Path;
 import net.javacrumbs.jsonunit.core.internal.matchers.InternalMatcher;
@@ -23,9 +24,6 @@
 import org.springframework.mock.http.client.MockClientHttpRequest;
 import org.springframework.test.web.client.RequestMatcher;
 
-import java.util.function.BiConsumer;
-
-
 /**
  * Matchers compatible with Spring mocking framework.
  * <p/>
@@ -63,9 +61,11 @@ public static JsonUnitRequestMatchers json() {
         return new JsonUnitRequestMatchers(Path.root(), Configuration.empty());
     }
 
-
     private static class JsonRequestMatcher extends AbstractSpringMatcher implements RequestMatcher {
-        private JsonRequestMatcher(@NotNull Path path, @NotNull Configuration configuration, @NotNull BiConsumer<Object, InternalMatcher> matcher) {
+        private JsonRequestMatcher(
+                @NotNull Path path,
+                @NotNull Configuration configuration,
+                @NotNull BiConsumer<Object, InternalMatcher> matcher) {
             super(path, configuration, matcher);
         }
 
diff --git a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitResultMatchers.java b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitResultMatchers.java
index 41c29b6e3..e01a52c99 100644
--- a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitResultMatchers.java
+++ b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/JsonUnitResultMatchers.java
@@ -15,6 +15,9 @@
  */
 package net.javacrumbs.jsonunit.spring;
 
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.util.function.BiConsumer;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.Path;
 import net.javacrumbs.jsonunit.core.internal.matchers.InternalMatcher;
@@ -23,10 +26,6 @@
 import org.springframework.test.web.servlet.MvcResult;
 import org.springframework.test.web.servlet.ResultMatcher;
 
-import java.io.UnsupportedEncodingException;
-import java.nio.charset.StandardCharsets;
-import java.util.function.BiConsumer;
-
 /**
  * Matchers compatible with Spring MVC test framework.
  * <p/>
@@ -60,9 +59,11 @@ JsonUnitResultMatchers matchers(@NotNull Path path, @NotNull Configuration confi
         return new JsonUnitResultMatchers(path, configuration);
     }
 
-
     private static class JsonResultMatcher extends AbstractSpringMatcher implements ResultMatcher {
-        private JsonResultMatcher(@NotNull Path path, @NotNull Configuration configuration, @NotNull BiConsumer<Object, InternalMatcher> matcher) {
+        private JsonResultMatcher(
+                @NotNull Path path,
+                @NotNull Configuration configuration,
+                @NotNull BiConsumer<Object, InternalMatcher> matcher) {
             super(path, configuration, matcher);
         }
 
@@ -73,7 +74,8 @@ public void match(@NotNull MvcResult result) throws Exception {
         }
 
         @NotNull
-        private String getContentAsString(@NotNull MockHttpServletResponse response) throws UnsupportedEncodingException {
+        private String getContentAsString(@NotNull MockHttpServletResponse response)
+                throws UnsupportedEncodingException {
             return response.getContentAsString(StandardCharsets.UTF_8);
         }
     }
diff --git a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/Utils.java b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/Utils.java
index 21273c1cf..74a97a810 100644
--- a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/Utils.java
+++ b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/Utils.java
@@ -1,13 +1,12 @@
 package net.javacrumbs.jsonunit.spring;
 
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.http.InvalidMediaTypeException;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.reactive.server.EntityExchangeResult;
 
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-
 class Utils {
     static String getContentAsString(EntityExchangeResult<byte[]> result) {
         Charset charset = getCharset(result);
@@ -22,7 +21,7 @@ private static Charset getCharset(EntityExchangeResult<byte[]> result) {
                 return contentType.getCharset();
             }
         } catch (InvalidMediaTypeException e) {
-            //ignore
+            // ignore
         }
         return StandardCharsets.UTF_8;
     }
diff --git a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/WebTestClientJsonMatcher.java b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/WebTestClientJsonMatcher.java
index 20921de68..dd24b0a9d 100644
--- a/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/WebTestClientJsonMatcher.java
+++ b/json-unit-spring/src/main/java/net/javacrumbs/jsonunit/spring/WebTestClientJsonMatcher.java
@@ -1,16 +1,15 @@
 package net.javacrumbs.jsonunit.spring;
 
+import static net.javacrumbs.jsonunit.spring.Utils.getContentAsString;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.internal.Path;
 import net.javacrumbs.jsonunit.core.internal.matchers.InternalMatcher;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.test.web.reactive.server.EntityExchangeResult;
 
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-import static net.javacrumbs.jsonunit.spring.Utils.getContentAsString;
-
 /**
  * Matcher compatible with Spring TestWebClient.
  * <p/>
@@ -21,7 +20,8 @@
  * .consumeWith(json().isEqualTo(CORRECT_JSON));
  * </code>
  */
-public class WebTestClientJsonMatcher extends AbstractSpringMatchers<WebTestClientJsonMatcher, Consumer<EntityExchangeResult<byte[]>>> {
+public class WebTestClientJsonMatcher
+        extends AbstractSpringMatchers<WebTestClientJsonMatcher, Consumer<EntityExchangeResult<byte[]>>> {
     private WebTestClientJsonMatcher(Path path, Configuration configuration) {
         super(path, configuration);
     }
@@ -42,8 +42,12 @@ WebTestClientJsonMatcher matchers(@NotNull Path path, @NotNull Configuration con
         return new WebTestClientJsonMatcher(path, configuration);
     }
 
-    private static class JsonUnitWebTestClientMatcher extends AbstractSpringMatcher implements Consumer<EntityExchangeResult<byte[]>> {
-        private JsonUnitWebTestClientMatcher(@NotNull Path path, @NotNull Configuration configuration, @NotNull BiConsumer<Object, InternalMatcher> matcher) {
+    private static class JsonUnitWebTestClientMatcher extends AbstractSpringMatcher
+            implements Consumer<EntityExchangeResult<byte[]>> {
+        private JsonUnitWebTestClientMatcher(
+                @NotNull Path path,
+                @NotNull Configuration configuration,
+                @NotNull BiConsumer<Object, InternalMatcher> matcher) {
             super(path, configuration, matcher);
         }
 
diff --git a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/ClientTest.java b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/ClientTest.java
index 13e41b285..2a560e3a9 100644
--- a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/ClientTest.java
+++ b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/ClientTest.java
@@ -15,12 +15,6 @@
  */
 package net.javacrumbs.jsonunit.spring.testit;
 
-import org.junit.jupiter.api.Test;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
-import org.springframework.test.web.client.MockRestServiceServer;
-import org.springframework.web.client.RestTemplate;
-
 import static net.javacrumbs.jsonunit.spring.JsonUnitRequestMatchers.json;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -28,6 +22,12 @@
 import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
 import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
 
+import org.junit.jupiter.api.Test;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.client.MockRestServiceServer;
+import org.springframework.web.client.RestTemplate;
+
 class ClientTest {
     private static final String URI = "/sample";
     private final RestTemplate restTemplate = new RestTemplate();
@@ -39,35 +39,39 @@ class ClientTest {
 
     @Test
     void shouldAssertClient() {
-        mockServer.expect(requestTo(URI))
-            .andExpect(json().isEqualTo(json))
-            .andRespond(withSuccess(jsonResponse, MediaType.APPLICATION_JSON));
-
-        assertThat(restTemplate.postForEntity(URI, json, String.class).getBody()).isEqualTo(jsonResponse);
+        mockServer
+                .expect(requestTo(URI))
+                .andExpect(json().isEqualTo(json))
+                .andRespond(withSuccess(jsonResponse, MediaType.APPLICATION_JSON));
 
+        assertThat(restTemplate.postForEntity(URI, json, String.class).getBody())
+                .isEqualTo(jsonResponse);
     }
 
     @Test
     void shouldFailOnMismatch() {
-        mockServer.expect(requestTo(URI))
-            .andExpect(json().isEqualTo("[]"))
-            .andRespond(withSuccess(jsonResponse, MediaType.APPLICATION_JSON));
+        mockServer
+                .expect(requestTo(URI))
+                .andExpect(json().isEqualTo("[]"))
+                .andRespond(withSuccess(jsonResponse, MediaType.APPLICATION_JSON));
 
         assertThatThrownBy(() -> restTemplate.postForEntity(URI, json, String.class))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "", expected: <[]> but was: <{"test":1}>.
                 """);
-
     }
 
     @Test
     void shouldAssertClientComplex() {
-        mockServer.expect(requestTo(URI))
-            .andExpect(method(HttpMethod.POST))
-            .andExpect(json().node("test").withTolerance(0.1).isEqualTo(0.99))
-            .andRespond(withSuccess(jsonResponse, MediaType.APPLICATION_JSON));
+        mockServer
+                .expect(requestTo(URI))
+                .andExpect(method(HttpMethod.POST))
+                .andExpect(json().node("test").withTolerance(0.1).isEqualTo(0.99))
+                .andRespond(withSuccess(jsonResponse, MediaType.APPLICATION_JSON));
 
-        assertThat(restTemplate.postForEntity(URI, json, String.class).getBody()).isEqualTo(jsonResponse);
+        assertThat(restTemplate.postForEntity(URI, json, String.class).getBody())
+                .isEqualTo(jsonResponse);
     }
 }
diff --git a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/MockMvcTest.java b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/MockMvcTest.java
index e35c1b4c8..4ae9537a2 100644
--- a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/MockMvcTest.java
+++ b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/MockMvcTest.java
@@ -15,6 +15,19 @@
  */
 package net.javacrumbs.jsonunit.spring.testit;
 
+import static java.math.BigDecimal.valueOf;
+import static net.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
+import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.CORRECT_JSON;
+import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.ISO_VALUE;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.Matchers.everyItem;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
 import net.javacrumbs.jsonunit.core.Option;
 import net.javacrumbs.jsonunit.core.listener.Difference;
 import net.javacrumbs.jsonunit.core.listener.DifferenceContext;
@@ -33,19 +46,6 @@
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 import org.springframework.web.context.WebApplicationContext;
 
-import static java.math.BigDecimal.valueOf;
-import static net.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
-import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.CORRECT_JSON;
-import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.ISO_VALUE;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.hamcrest.Matchers.everyItem;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
-
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {SpringConfig.class})
 @WebAppConfiguration
@@ -78,8 +78,10 @@ void shouldPassIfEquals() throws Exception {
     @Test
     void isEqualToShouldFailIfDoesNotEqual() {
         DifferenceListener listener = mock(DifferenceListener.class);
-        assertThatThrownBy(() -> exec().andExpect(json().withDifferenceListener(listener).isEqualTo(CORRECT_JSON.replace("stringValue", "stringValue2"))))
-            .hasMessage("""
+        assertThatThrownBy(() -> exec().andExpect(json().withDifferenceListener(listener)
+                        .isEqualTo(CORRECT_JSON.replace("stringValue", "stringValue2"))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <"stringValue2"> but was: <"stringValue">.
                 """);
@@ -90,11 +92,11 @@ void isEqualToShouldFailIfDoesNotEqual() {
     @Test
     void isEqualToInNodeFailIfDoesNotEqual() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.string").isEqualTo("stringValue2")))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <"stringValue2"> but was: <"stringValue">.
                 """);
-
     }
 
     @Test
@@ -105,13 +107,14 @@ void isNullShouldPassOnNull() throws Exception {
     @Test
     void isNullShouldFailOnNonNull() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.string").isNull()))
-            .hasMessage("Node \"result.string\" has invalid type, expected: <a null> but was: <\"stringValue\">.");
+                .hasMessage("Node \"result.string\" has invalid type, expected: <a null> but was: <\"stringValue\">.");
     }
 
     @Test
     void isNullShouldFailOnMissing() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.missing").isNull()))
-            .hasMessage("Different value found in node \"result.missing\", expected: <node to be present> but was: <missing>.");
+                .hasMessage(
+                        "Different value found in node \"result.missing\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -122,13 +125,13 @@ void isNotNullShouldPassOnString() throws Exception {
     @Test
     void isNotNullShouldFailOnNull() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.null").isNotNull()))
-            .hasMessage("Node \"result.null\" has invalid type, expected: <not null> but was: <null>.");
+                .hasMessage("Node \"result.null\" has invalid type, expected: <not null> but was: <null>.");
     }
 
     @Test
     void isStringEqualToShouldFailOnNumber() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.array[0]").isStringEqualTo("1")))
-            .hasMessage("Node \"result.array[0]\" has invalid type, expected: <string> but was: <1>.");
+                .hasMessage("Node \"result.array[0]\" has invalid type, expected: <string> but was: <1>.");
     }
 
     @Test
@@ -139,7 +142,8 @@ void isTrueShouldPassOnTrue() throws Exception {
     @Test
     void isFalseShouldFailOnTrue() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.boolean").isFalse()))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "result.boolean", expected: <false> but was: <true>.
                 """);
@@ -148,7 +152,8 @@ void isFalseShouldFailOnTrue() {
     @Test
     void isTrueShouldFailOnString() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.string").isTrue()))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <true> but was: <"stringValue">.
                 """);
@@ -162,10 +167,10 @@ void isStringEqualToShouldPassIfEquals() throws Exception {
     @Test
     void isAbsentShouldFailIfNodeExists() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.string").isAbsent()))
-            .hasMessage("Different value found in node \"result.string\", expected: <node to be absent> but was: <\"stringValue\">.");
+                .hasMessage(
+                        "Different value found in node \"result.string\", expected: <node to be absent> but was: <\"stringValue\">.");
     }
 
-
     @Test
     void isAbsentShouldPassIfNodeIsAbsent() throws Exception {
         exec().andExpect(json().node("result.string2").isAbsent());
@@ -174,7 +179,8 @@ void isAbsentShouldPassIfNodeIsAbsent() throws Exception {
     @Test
     void isPresentShouldFailIfNodeIsAbsent() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.string2").isPresent()))
-            .hasMessage("Different value found in node \"result.string2\", expected: <node to be present> but was: <missing>.");
+                .hasMessage(
+                        "Different value found in node \"result.string2\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -185,26 +191,25 @@ void isPresentShouldPassIfPresent() throws Exception {
     @Test
     void isArrayShouldFailOnNotArray() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.string").isArray()))
-            .hasMessage("Node \"result.string\" has invalid type, expected: <array> but was: <\"stringValue\">.");
+                .hasMessage("Node \"result.string\" has invalid type, expected: <array> but was: <\"stringValue\">.");
     }
 
     @Test
     void isArrayShouldFailIfNotPresent() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.array2").isArray()))
-            .hasMessage("Different value found in node \"result.array2\", expected: <array> but was: <missing>.");
+                .hasMessage("Different value found in node \"result.array2\", expected: <array> but was: <missing>.");
     }
 
-
     @Test
     void isObjectShouldFailOnArray() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.array").isObject()))
-            .hasMessage("Node \"result.array\" has invalid type, expected: <object> but was: <[1, 2, 3]>.");
+                .hasMessage("Node \"result.array\" has invalid type, expected: <object> but was: <[1, 2, 3]>.");
     }
 
     @Test
     void isStringShouldFailOnArray() {
         assertThatThrownBy(() -> exec().andExpect(json().node("result.array").isString()))
-            .hasMessage("Node \"result.array\" has invalid type, expected: <string> but was: <[1, 2, 3]>.");
+                .hasMessage("Node \"result.array\" has invalid type, expected: <string> but was: <[1, 2, 3]>.");
     }
 
     @Test
@@ -229,20 +234,22 @@ void shouldSetTolerance() throws Exception {
 
     @Test
     void settingOptionShouldTakeEffect() throws Exception {
-        exec().andExpect(json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(new int[]{3, 2, 1}));
+        exec().andExpect(json().node("result.array")
+                .when(Option.IGNORING_ARRAY_ORDER)
+                .isEqualTo(new int[] {3, 2, 1}));
     }
 
     @Test
     void isNotEqualToShouldFailIfEquals() {
         assertThatThrownBy(() -> exec().andExpect(json().isNotEqualTo(CORRECT_JSON)))
-            .hasMessage("JSON is equal.");
+                .hasMessage("JSON is equal.");
     }
 
     @Test
     void isEqualToShouldFailIfNodeDoesNotEqual() {
-        assertThatThrownBy(() -> exec()
-            .andExpect(json().node("result.string").isEqualTo("stringValue2")))
-            .hasMessage("""
+        assertThatThrownBy(() -> exec().andExpect(json().node("result.string").isEqualTo("stringValue2")))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <"stringValue2"> but was: <"stringValue">.
                 """);
@@ -255,8 +262,10 @@ void intValueShouldMatch() throws Exception {
 
     @Test
     void intValueShouldFailIfDoesNotMatch() {
-        assertThatThrownBy(() -> exec().andExpect(json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(2))))))
-            .hasMessage("""
+        assertThatThrownBy(() ->
+                        exec().andExpect(json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(2))))))
+                .hasMessage(
+                        """
                 Node "result.array" does not match.
                 Expected: every item is a value less than or equal to <2>
                      but: an item <3> was greater than <2>""");
@@ -268,7 +277,9 @@ private ResultActions exec() {
 
     private ResultActions exec(String path) {
         try {
-            return this.mockMvc.perform(get(path).accept(MediaType.APPLICATION_JSON)).andExpect(status().isOk());
+            return this.mockMvc
+                    .perform(get(path).accept(MediaType.APPLICATION_JSON))
+                    .andExpect(status().isOk());
         } catch (Exception e) {
             throw new IllegalStateException(e);
         }
diff --git a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/WebTestClientTest.java b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/WebTestClientTest.java
index 614b50cf1..4ff47f75f 100644
--- a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/WebTestClientTest.java
+++ b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/WebTestClientTest.java
@@ -15,6 +15,18 @@
  */
 package net.javacrumbs.jsonunit.spring.testit;
 
+import static java.math.BigDecimal.valueOf;
+import static net.javacrumbs.jsonunit.spring.WebTestClientJsonMatcher.json;
+import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.CORRECT_JSON;
+import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.ISO_VALUE;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.Matchers.everyItem;
+import static org.hamcrest.Matchers.lessThan;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
 import net.javacrumbs.jsonunit.core.Option;
 import net.javacrumbs.jsonunit.core.listener.Difference;
 import net.javacrumbs.jsonunit.core.listener.DifferenceContext;
@@ -32,18 +44,6 @@
 import org.springframework.test.web.servlet.client.MockMvcWebTestClient;
 import org.springframework.web.context.WebApplicationContext;
 
-import static java.math.BigDecimal.valueOf;
-import static net.javacrumbs.jsonunit.spring.WebTestClientJsonMatcher.json;
-import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.CORRECT_JSON;
-import static net.javacrumbs.jsonunit.spring.testit.demo.ExampleController.ISO_VALUE;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.hamcrest.Matchers.everyItem;
-import static org.hamcrest.Matchers.lessThan;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {SpringConfig.class})
 @WebAppConfiguration
@@ -77,8 +77,10 @@ void shouldPassIfEquals() {
     @Test
     void isEqualToShouldFailIfDoesNotEqual() {
         DifferenceListener listener = mock(DifferenceListener.class);
-        assertThatThrownBy(() -> exec().consumeWith(json().withDifferenceListener(listener).isEqualTo(CORRECT_JSON.replace("stringValue", "stringValue2"))))
-            .hasMessageStartingWith("""
+        assertThatThrownBy(() -> exec().consumeWith(json().withDifferenceListener(listener)
+                        .isEqualTo(CORRECT_JSON.replace("stringValue", "stringValue2"))))
+                .hasMessageStartingWith(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <"stringValue2"> but was: <"stringValue">.
                 """);
@@ -89,22 +91,22 @@ void isEqualToShouldFailIfDoesNotEqual() {
     @Test
     void isEqualToInNodeFailIfDoesNotEqual() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.string").isEqualTo("stringValue2")))
-            .hasMessageStartingWith("""
+                .hasMessageStartingWith(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <"stringValue2"> but was: <"stringValue">.
                 """);
-
     }
+
     @Test
     void useMatcher() {
-        assertThatThrownBy(() -> exec().consumeWith(json()
-            .withMatcher("negative", lessThan(valueOf(0)))
-            .node("result.decimal").isEqualTo("${json-unit.matches:negative}")))
-            .hasMessage("JSON documents are different:\nMatcher \"negative\" does not match value 1.00001 in node \"result.decimal\". <1.00001> was greater than <0>\n");
-
+        assertThatThrownBy(() -> exec().consumeWith(json().withMatcher("negative", lessThan(valueOf(0)))
+                        .node("result.decimal")
+                        .isEqualTo("${json-unit.matches:negative}")))
+                .hasMessage(
+                        "JSON documents are different:\nMatcher \"negative\" does not match value 1.00001 in node \"result.decimal\". <1.00001> was greater than <0>\n");
     }
 
-
     @Test
     void isNullShouldPassOnNull() {
         exec().consumeWith(json().node("result.null").isNull());
@@ -113,13 +115,16 @@ void isNullShouldPassOnNull() {
     @Test
     void isNullShouldFailOnNonNull() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.string").isNull()))
-            .hasMessageStartingWith("Node \"result.string\" has invalid type, expected: <a null> but was: <\"stringValue\">.");
+                .hasMessageStartingWith(
+                        "Node \"result.string\" has invalid type, expected: <a null> but was: <\"stringValue\">.");
     }
 
     @Test
     void isNullShouldFailOnMissing() {
-        assertThatThrownBy(() -> exec().consumeWith(json().node("result.missing").isNull()))
-            .hasMessageStartingWith("Different value found in node \"result.missing\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(
+                        () -> exec().consumeWith(json().node("result.missing").isNull()))
+                .hasMessageStartingWith(
+                        "Different value found in node \"result.missing\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -130,13 +135,14 @@ void isNotNullShouldPassOnString() {
     @Test
     void isNotNullShouldFailOnNull() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.null").isNotNull()))
-            .hasMessageStartingWith("Node \"result.null\" has invalid type, expected: <not null> but was: <null>.");
+                .hasMessageStartingWith("Node \"result.null\" has invalid type, expected: <not null> but was: <null>.");
     }
 
     @Test
     void isStringEqualToShouldFailOnNumber() {
-        assertThatThrownBy(() -> exec().consumeWith(json().node("result.array[0]").isStringEqualTo("1")))
-            .hasMessageStartingWith("Node \"result.array[0]\" has invalid type, expected: <string> but was: <1>.");
+        assertThatThrownBy(
+                        () -> exec().consumeWith(json().node("result.array[0]").isStringEqualTo("1")))
+                .hasMessageStartingWith("Node \"result.array[0]\" has invalid type, expected: <string> but was: <1>.");
     }
 
     @Test
@@ -146,8 +152,10 @@ void isTrueShouldPassOnTrue() {
 
     @Test
     void isFalseShouldFailOnTrue() {
-        assertThatThrownBy(() -> exec().consumeWith(json().node("result.boolean").isFalse()))
-            .hasMessageStartingWith("""
+        assertThatThrownBy(
+                        () -> exec().consumeWith(json().node("result.boolean").isFalse()))
+                .hasMessageStartingWith(
+                        """
                 JSON documents are different:
                 Different value found in node "result.boolean", expected: <false> but was: <true>.
                 """);
@@ -156,7 +164,8 @@ void isFalseShouldFailOnTrue() {
     @Test
     void isTrueShouldFailOnString() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.string").isTrue()))
-            .hasMessageStartingWith("""
+                .hasMessageStartingWith(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <true> but was: <"stringValue">.
                 """);
@@ -170,10 +179,10 @@ void isStringEqualToShouldPassIfEquals() {
     @Test
     void isAbsentShouldFailIfNodeExists() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.string").isAbsent()))
-            .hasMessageStartingWith("Different value found in node \"result.string\", expected: <node to be absent> but was: <\"stringValue\">.");
+                .hasMessageStartingWith(
+                        "Different value found in node \"result.string\", expected: <node to be absent> but was: <\"stringValue\">.");
     }
 
-
     @Test
     void isAbsentShouldPassIfNodeIsAbsent() {
         exec().consumeWith(json().node("result.string2").isAbsent());
@@ -181,8 +190,10 @@ void isAbsentShouldPassIfNodeIsAbsent() {
 
     @Test
     void isPresentShouldFailIfNodeIsAbsent() {
-        assertThatThrownBy(() -> exec().consumeWith(json().node("result.string2").isPresent()))
-            .hasMessageStartingWith("Different value found in node \"result.string2\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(
+                        () -> exec().consumeWith(json().node("result.string2").isPresent()))
+                .hasMessageStartingWith(
+                        "Different value found in node \"result.string2\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -193,26 +204,29 @@ void isPresentShouldPassIfPresent() {
     @Test
     void isArrayShouldFailOnNotArray() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.string").isArray()))
-            .hasMessageStartingWith("Node \"result.string\" has invalid type, expected: <array> but was: <\"stringValue\">.");
+                .hasMessageStartingWith(
+                        "Node \"result.string\" has invalid type, expected: <array> but was: <\"stringValue\">.");
     }
 
     @Test
     void isArrayShouldFailIfNotPresent() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.array2").isArray()))
-            .hasMessageStartingWith("Different value found in node \"result.array2\", expected: <array> but was: <missing>.");
+                .hasMessageStartingWith(
+                        "Different value found in node \"result.array2\", expected: <array> but was: <missing>.");
     }
 
-
     @Test
     void isObjectShouldFailOnArray() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.array").isObject()))
-            .hasMessageStartingWith("Node \"result.array\" has invalid type, expected: <object> but was: <[1, 2, 3]>.");
+                .hasMessageStartingWith(
+                        "Node \"result.array\" has invalid type, expected: <object> but was: <[1, 2, 3]>.");
     }
 
     @Test
     void isStringShouldFailOnArray() {
         assertThatThrownBy(() -> exec().consumeWith(json().node("result.array").isString()))
-            .hasMessageStartingWith("Node \"result.array\" has invalid type, expected: <string> but was: <[1, 2, 3]>.");
+                .hasMessageStartingWith(
+                        "Node \"result.array\" has invalid type, expected: <string> but was: <[1, 2, 3]>.");
     }
 
     @Test
@@ -237,20 +251,22 @@ void shouldSetTolerance() {
 
     @Test
     void settingOptionShouldTakeEffect() {
-        exec().consumeWith(json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(new int[]{3, 2, 1}));
+        exec().consumeWith(json().node("result.array")
+                .when(Option.IGNORING_ARRAY_ORDER)
+                .isEqualTo(new int[] {3, 2, 1}));
     }
 
     @Test
     void isNotEqualToShouldFailIfEquals() {
         assertThatThrownBy(() -> exec().consumeWith(json().isNotEqualTo(CORRECT_JSON)))
-            .hasMessageStartingWith("JSON is equal.");
+                .hasMessageStartingWith("JSON is equal.");
     }
 
     @Test
     void isEqualToShouldFailIfNodeDoesNotEqual() {
-        assertThatThrownBy(() -> exec()
-            .consumeWith(json().node("result.string").isEqualTo("stringValue2")))
-            .hasMessageStartingWith("""
+        assertThatThrownBy(() -> exec().consumeWith(json().node("result.string").isEqualTo("stringValue2")))
+                .hasMessageStartingWith(
+                        """
                 JSON documents are different:
                 Different value found in node "result.string", expected: <"stringValue2"> but was: <"stringValue">.
                 """);
@@ -263,8 +279,10 @@ void intValueShouldMatch() {
 
     @Test
     void intValueShouldFailIfDoesNotMatch() {
-        assertThatThrownBy(() -> exec().consumeWith(json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(2))))))
-            .hasMessageStartingWith("""
+        assertThatThrownBy(() -> exec().consumeWith(
+                                json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(2))))))
+                .hasMessageStartingWith(
+                        """
                 Node "result.array" does not match.
                 Expected: every item is a value less than or equal to <2>
                      but: an item <3> was greater than <2>""");
@@ -276,7 +294,12 @@ private WebTestClient.BodyContentSpec exec() {
 
     private WebTestClient.BodyContentSpec exec(String path) {
         try {
-            return this.client.get().uri(path).accept(MediaType.APPLICATION_JSON).exchange().expectBody();
+            return this.client
+                    .get()
+                    .uri(path)
+                    .accept(MediaType.APPLICATION_JSON)
+                    .exchange()
+                    .expectBody();
         } catch (Exception e) {
             throw new IllegalStateException(e);
         }
diff --git a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/ExampleController.java b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/ExampleController.java
index 1f4f3e95a..4997e533f 100644
--- a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/ExampleController.java
+++ b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/ExampleController.java
@@ -15,6 +15,11 @@
  */
 package net.javacrumbs.jsonunit.spring.testit.demo;
 
+import static java.util.Collections.singletonMap;
+import static org.springframework.http.MediaType.parseMediaType;
+
+import java.math.BigDecimal;
+import java.nio.charset.Charset;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -22,12 +27,6 @@
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
-import java.math.BigDecimal;
-import java.nio.charset.Charset;
-
-import static java.util.Collections.singletonMap;
-import static org.springframework.http.MediaType.parseMediaType;
-
 @RestController
 public class ExampleController {
 
@@ -50,9 +49,7 @@ public Object getWithProduces() {
     }
 
     @GetMapping(value = "/empty")
-    public void empty() {
-    }
-
+    public void empty() {}
 
     private static class Result {
         public String getString() {
@@ -60,12 +57,13 @@ public String getString() {
         }
 
         public int[] getArray() {
-            return new int[]{1, 2, 3};
+            return new int[] {1, 2, 3};
         }
 
         public BigDecimal getDecimal() {
             return new BigDecimal("1.00001");
         }
+
         public boolean getBoolean() {
             return true;
         }
@@ -79,7 +77,8 @@ public String getUtf8() {
         }
     }
 
-    public static final String CORRECT_JSON = "{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001, \"boolean\": true, \"null\" : null, \"utf8\":\"€\"}}";
+    public static final String CORRECT_JSON =
+            "{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001, \"boolean\": true, \"null\" : null, \"utf8\":\"€\"}}";
 
     public static final String ISO_VALUE = "Příliš žluťoučký kůň";
 }
diff --git a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/SpringConfig.java b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/SpringConfig.java
index a3fba55b8..bb05978bc 100644
--- a/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/SpringConfig.java
+++ b/json-unit-spring/src/test/java/net/javacrumbs/jsonunit/spring/testit/demo/SpringConfig.java
@@ -22,6 +22,4 @@
 @Configuration
 @ComponentScan("net.javacrumbs.jsonunit.spring.testit.demo")
 @EnableWebMvc
-public class SpringConfig {
-
-}
+public class SpringConfig {}
diff --git a/json-unit/src/main/java/net/javacrumbs/jsonunit/ConfigurableJsonMatcher.java b/json-unit/src/main/java/net/javacrumbs/jsonunit/ConfigurableJsonMatcher.java
index 68b9aa94c..daaea1e30 100644
--- a/json-unit/src/main/java/net/javacrumbs/jsonunit/ConfigurableJsonMatcher.java
+++ b/json-unit/src/main/java/net/javacrumbs/jsonunit/ConfigurableJsonMatcher.java
@@ -15,6 +15,8 @@
  */
 package net.javacrumbs.jsonunit;
 
+import java.math.BigDecimal;
+import java.util.Collection;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
@@ -22,9 +24,6 @@
 import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
 import org.hamcrest.Matcher;
 
-import java.math.BigDecimal;
-import java.util.Collection;
-
 /**
  * JsonMatcher interface.
  *
@@ -73,5 +72,5 @@ public interface ConfigurableJsonMatcher<T> extends Matcher<T> {
      *
      * @see Configuration#when(PathsParam, ApplicableForPath...)
      */
-   ConfigurableJsonMatcher<T> when(PathsParam object, ApplicableForPath... actions);
+    ConfigurableJsonMatcher<T> when(PathsParam object, ApplicableForPath... actions);
 }
diff --git a/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonAssert.java b/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonAssert.java
index 6f3ad5e68..0567399fc 100644
--- a/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonAssert.java
+++ b/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonAssert.java
@@ -15,6 +15,10 @@
  */
 package net.javacrumbs.jsonunit;
 
+import static net.javacrumbs.jsonunit.core.internal.Diff.create;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.nodeAbsent;
+
+import java.math.BigDecimal;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
@@ -23,11 +27,6 @@
 import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
 import org.hamcrest.Matcher;
 
-import java.math.BigDecimal;
-
-import static net.javacrumbs.jsonunit.core.internal.Diff.create;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.nodeAbsent;
-
 /**
  * Assertions for comparing JSON. The comparison ignores white-spaces and order of nodes.
  *
@@ -49,7 +48,7 @@ public class JsonAssert {
     private static Configuration configuration = Configuration.empty();
 
     private JsonAssert() {
-        //nothing
+        // nothing
     }
 
     /**
@@ -76,7 +75,8 @@ public static void assertJsonPartEquals(Object expected, Object fullJson, String
     /**
      * Compares part of the JSON. Path has this format "root.array[0].value".
      */
-    public static void assertJsonPartEquals(Object expected, Object fullJson, String path, Configuration configuration) {
+    public static void assertJsonPartEquals(
+            Object expected, Object fullJson, String path, Configuration configuration) {
         Diff diff = create(expected, fullJson, FULL_JSON, path, configuration);
         diff.failIfDifferent();
     }
@@ -107,7 +107,8 @@ public static void assertJsonPartNotEquals(Object expected, Object fullJson, Str
      * Compares part of the JSON and fails if they are equal.
      * Path has this format "root.array[0].value".
      */
-    public static void assertJsonPartNotEquals(Object expected, Object fullJson, String path, Configuration configuration) {
+    public static void assertJsonPartNotEquals(
+            Object expected, Object fullJson, String path, Configuration configuration) {
         Diff diff = create(expected, fullJson, FULL_JSON, path, configuration);
         if (diff.similar()) {
             if (ROOT.equals(path)) {
@@ -118,7 +119,6 @@ public static void assertJsonPartNotEquals(Object expected, Object fullJson, Str
         }
     }
 
-
     /**
      * Fails if node in given path exists.
      */
diff --git a/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonMatchers.java b/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonMatchers.java
index 737c37608..297f5492e 100644
--- a/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonMatchers.java
+++ b/json-unit/src/main/java/net/javacrumbs/jsonunit/JsonMatchers.java
@@ -15,6 +15,15 @@
  */
 package net.javacrumbs.jsonunit;
 
+import static net.javacrumbs.jsonunit.core.internal.Diff.createInternal;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getNode;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
+import static net.javacrumbs.jsonunit.core.internal.JsonUtils.nodeAbsent;
+
+import java.math.BigDecimal;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.Map;
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
@@ -27,16 +36,6 @@
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 
-import java.math.BigDecimal;
-import java.util.Collection;
-import java.util.IdentityHashMap;
-import java.util.Map;
-
-import static net.javacrumbs.jsonunit.core.internal.Diff.createInternal;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getNode;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
-import static net.javacrumbs.jsonunit.core.internal.JsonUtils.nodeAbsent;
-
 /**
  * Contains Hamcrest matchers to be used with Hamcrest assertThat and other tools.
  * <p/>
@@ -109,7 +108,7 @@ public static <T> ConfigurableJsonMatcher<T> jsonNodePresent(String path) {
         return new JsonNodePresenceMatcher<>(path);
     }
 
-    private static abstract class AbstractMatcher<T> extends BaseMatcher<T> {
+    private abstract static class AbstractMatcher<T> extends BaseMatcher<T> {
         final String path;
         Object actual;
 
@@ -130,11 +129,11 @@ Path getPath() {
         }
     }
 
-    private static abstract class AbstractJsonMatcher<T> extends AbstractMatcher<T> implements ConfigurableJsonMatcher<T> {
+    private abstract static class AbstractJsonMatcher<T> extends AbstractMatcher<T>
+            implements ConfigurableJsonMatcher<T> {
 
         Configuration configuration = JsonAssert.getConfiguration();
 
-
         AbstractJsonMatcher(String path) {
             super(path);
         }
@@ -196,12 +195,15 @@ public ConfigurableJsonMatcher<T> withDifferenceListener(DifferenceListener diff
     }
 
     private static final class JsonPartMatcher<T> extends AbstractJsonMatcher<T> {
-        // IntelliJ integration is broken by default difference string. Hamcrest generates 'Expected:' and IntelliJ searches for last 'but was:' and everything between is taken as expected value
+        // IntelliJ integration is broken by default difference string. Hamcrest generates 'Expected:' and IntelliJ
+        // searches for last 'but was:' and everything between is taken as expected value
         private static final String HAMCREST_DIFFERENCE_STRING = "expected <%s> but was <%s>";
         private final Object expected;
 
-        // One matcher can be used to match multiple array items. We need to persist diff description between doMatch() and
-        // describeMismatch() method calls. While Hamcrest 1 called doMatch() and describeMismatch() one after each other
+        // One matcher can be used to match multiple array items. We need to persist diff description between doMatch()
+        // and
+        // describeMismatch() method calls. While Hamcrest 1 called doMatch() and describeMismatch() one after each
+        // other
         // Hamcrest 2 calls doMatch() multiple times followed by multiple calls of describeMismatch()
         // using IdentityHashMap since not all compared object do have to implement hashCode and equals
         private final Map<Object, String> differences = new IdentityHashMap<>();
@@ -213,7 +215,8 @@ private static final class JsonPartMatcher<T> extends AbstractJsonMatcher<T> {
 
         @Override
         boolean doMatch(Object item) {
-            Diff diff = createInternal(expected, item, FULL_JSON,  Path.create(path, ""), configuration, HAMCREST_DIFFERENCE_STRING);
+            Diff diff = createInternal(
+                    expected, item, FULL_JSON, Path.create(path, ""), configuration, HAMCREST_DIFFERENCE_STRING);
             if (!diff.similar()) {
                 differences.put(item, diff.differences());
             }
@@ -225,7 +228,11 @@ public void describeTo(Description description) {
             if (EMPTY_PATH.equals(path)) {
                 description.appendText(safeToString());
             } else {
-                description.appendText(safeToString()).appendText(" in \"").appendText(path).appendText("\"");
+                description
+                        .appendText(safeToString())
+                        .appendText(" in \"")
+                        .appendText(path)
+                        .appendText("\"");
             }
         }
 
@@ -249,7 +256,6 @@ private String getDifference(Object item) {
         }
     }
 
-
     private static final class JsonNodeAbsenceMatcher<T> extends AbstractJsonMatcher<T> {
         JsonNodeAbsenceMatcher(String path) {
             super(path);
diff --git a/pom.xml b/pom.xml
index 60b9fe3fd..85df648bc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -112,6 +112,17 @@
 
     <build>
         <plugins>
+            <plugin>
+                <groupId>com.diffplug.spotless</groupId>
+                <artifactId>spotless-maven-plugin</artifactId>
+                <version>2.40.0</version>
+                <configuration>
+                    <java>
+                        <palantirJavaFormat><version>2.38.0</version></palantirJavaFormat>
+                        <removeUnusedImports/>
+                    </java>
+                </configuration>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractAssertJTest.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractAssertJTest.java
index 8f3c8b179..e04edfa55 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractAssertJTest.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractAssertJTest.java
@@ -15,22 +15,6 @@
  */
 package net.javacrumbs.jsonunit.test.base;
 
-import net.javacrumbs.jsonunit.assertj.JsonAssert;
-import net.javacrumbs.jsonunit.assertj.JsonAssert.ConfigurableJsonAssert;
-import net.javacrumbs.jsonunit.core.NumberComparator;
-import net.javacrumbs.jsonunit.core.Option;
-import net.javacrumbs.jsonunit.test.base.AbstractJsonAssertTest.DivisionMatcher;
-import org.hamcrest.Matcher;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.opentest4j.AssertionFailedError;
-import org.opentest4j.MultipleFailuresError;
-
-import java.math.BigDecimal;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
 import static java.math.BigDecimal.valueOf;
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
@@ -59,6 +43,21 @@
 import static org.hamcrest.Matchers.greaterThan;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.math.BigDecimal;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import net.javacrumbs.jsonunit.assertj.JsonAssert;
+import net.javacrumbs.jsonunit.assertj.JsonAssert.ConfigurableJsonAssert;
+import net.javacrumbs.jsonunit.core.NumberComparator;
+import net.javacrumbs.jsonunit.core.Option;
+import net.javacrumbs.jsonunit.test.base.AbstractJsonAssertTest.DivisionMatcher;
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.opentest4j.AssertionFailedError;
+import org.opentest4j.MultipleFailuresError;
+
 public abstract class AbstractAssertJTest {
 
     @Test
@@ -112,32 +111,35 @@ void shouldAssertNullValueNode() {
 
     @Test
     void shouldFailCorrectlyOnNull() {
-        assertThatThrownBy(() ->
-            assertThatJson(null).isEqualTo(1)
-        ).hasMessage("JSON documents are different:\nDifferent value found in node \"\", expected: <1> but was: <null>.\n");
+        assertThatThrownBy(() -> assertThatJson(null).isEqualTo(1))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"\", expected: <1> but was: <null>.\n");
     }
 
     @Test
     void containsEntryShouldWork() {
-        String entryValue = "{\n" +
-            "  \"approvable\" : true," +
-            "  \"rejectable\" : false" +
-            "}";
+        String entryValue = "{\n" + "  \"approvable\" : true," + "  \"rejectable\" : false" + "}";
 
         String input = "[{\"allowedActions\":" + entryValue + "}]";
 
-        assertThatJson(input,
-            body -> body.isArray().hasSize(1),
-            body -> body.inPath("[0]").isObject().containsEntry("allowedActions", json(entryValue)),
-            body -> body.inPath("[0]").isObject().contains(entry("allowedActions", json(entryValue))),
-            body -> body.inPath("[0]").isObject().containsAllEntriesOf(singletonMap("allowedActions", json(entryValue))),
-            body -> body.inPath("[0]").isObject().containsAnyOf(entry("allowedActions", json(entryValue)), entry("test", 1)),
-            body -> body.inPath("[0]").isObject().containsExactlyInAnyOrderEntriesOf(singletonMap("allowedActions", json(entryValue))),
-            body -> body.inPath("[0]").isObject().containsOnly(entry("allowedActions", json(entryValue))),
-            body -> body.inPath("[0]").isObject().containsValues(json(entryValue)),
-            body -> body.inPath("[0]").isObject().containsValue(json(entryValue)),
-            body -> body.inPath("[0].allowedActions").isObject().isEqualTo(json(entryValue))
-        );
+        assertThatJson(
+                input,
+                body -> body.isArray().hasSize(1),
+                body -> body.inPath("[0]").isObject().containsEntry("allowedActions", json(entryValue)),
+                body -> body.inPath("[0]").isObject().contains(entry("allowedActions", json(entryValue))),
+                body -> body.inPath("[0]")
+                        .isObject()
+                        .containsAllEntriesOf(singletonMap("allowedActions", json(entryValue))),
+                body -> body.inPath("[0]")
+                        .isObject()
+                        .containsAnyOf(entry("allowedActions", json(entryValue)), entry("test", 1)),
+                body -> body.inPath("[0]")
+                        .isObject()
+                        .containsExactlyInAnyOrderEntriesOf(singletonMap("allowedActions", json(entryValue))),
+                body -> body.inPath("[0]").isObject().containsOnly(entry("allowedActions", json(entryValue))),
+                body -> body.inPath("[0]").isObject().containsValues(json(entryValue)),
+                body -> body.inPath("[0]").isObject().containsValue(json(entryValue)),
+                body -> body.inPath("[0].allowedActions").isObject().isEqualTo(json(entryValue)));
     }
 
     @Test
@@ -150,22 +152,24 @@ void containsEntryShouldWorkWithMatcher() {
     @Test
     void containsOnlyShouldWorkWithMatcher() {
         String json = "{\"a\": 1, \"b\": 2}";
-        assertThatJson(json).isObject().containsOnly(
-            entry("a", json("\"${json-unit.any-number}\"")),
-            entry("b", json("\"${json-unit.any-number}\""))
-        );
+        assertThatJson(json)
+                .isObject()
+                .containsOnly(
+                        entry("a", json("\"${json-unit.any-number}\"")),
+                        entry("b", json("\"${json-unit.any-number}\"")));
     }
 
     @Test
     void containsEntryShouldFailWithMatcher() {
         String json = "{\"a\": 1, \"b\": 2}";
 
-        assertThatThrownBy(() ->
-            assertThatJson(json).isObject().contains(
-                entry("a", json("\"${json-unit.any-string}\"")),
-                entry("b", json("\"${json-unit.any-number}\""))
-            )
-        ).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson(json)
+                        .isObject()
+                        .contains(
+                                entry("a", json("\"${json-unit.any-string}\"")),
+                                entry("b", json("\"${json-unit.any-number}\""))))
+                .hasMessage(
+                        """
             [Different value found in node ""]\s
             Expecting map:
               {"a":1,"b":2}
@@ -179,22 +183,24 @@ void containsEntryShouldFailWithMatcher() {
     @Test
     void containsAnyOfShouldWorkWithMatcher() {
         String json = "{\"a\": 1, \"b\": 2}";
-        assertThatJson(json).isObject().containsAnyOf(
-            entry("a", json("\"${json-unit.any-string}\"")),
-            entry("a", json("\"${json-unit.any-number}\""))
-        );
+        assertThatJson(json)
+                .isObject()
+                .containsAnyOf(
+                        entry("a", json("\"${json-unit.any-string}\"")),
+                        entry("a", json("\"${json-unit.any-number}\"")));
     }
 
     @Test
     void containsAnyOfShouldFailWithMatcher() {
         String json = "{\"a\": 1, \"b\": 2}";
 
-        assertThatThrownBy(() ->
-            assertThatJson(json).isObject().containsAnyOf(
-                entry("a", json("\"${json-unit.any-string}\"")),
-                entry("b", json("\"${json-unit.any-string}\""))
-            )
-        ).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson(json)
+                        .isObject()
+                        .containsAnyOf(
+                                entry("a", json("\"${json-unit.any-string}\"")),
+                                entry("b", json("\"${json-unit.any-string}\""))))
+                .hasMessage(
+                        """
             [Different value found in node ""]\s
             Expecting actual:
               {"a":1,"b":2}
@@ -212,9 +218,11 @@ void containsValuesShouldPass() {
     @Test
     void containsValuesShouldFail() {
         String json = "{\"a\": 1, \"b\": 2}";
-        assertThatThrownBy(() ->
-            assertThatJson(json).isObject().containsValues(valueOf(1), valueOf(2), json("\"${json-unit.any-string}\""))
-        ).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson(json)
+                        .isObject()
+                        .containsValues(valueOf(1), valueOf(2), json("\"${json-unit.any-string}\"")))
+                .hasMessage(
+                        """
             [Different value found in node ""]\s
             Expecting actual:
               {"a":1,"b":2}
@@ -231,9 +239,8 @@ void absentOnArray() {
 
     @Test
     void invalidExpectedValue() {
-        assertThatThrownBy(() ->
-            assertThatJson(json).isEqualTo("{\"broken\":")
-        ).hasMessage("Can not parse expected value: '{\"broken\":'");
+        assertThatThrownBy(() -> assertThatJson(json).isEqualTo("{\"broken\":"))
+                .hasMessage("Can not parse expected value: '{\"broken\":'");
     }
 
     @Test
@@ -243,16 +250,19 @@ void objectShouldContainValue() {
 
     @Test
     void objectShouldContainComplexValue() {
-        assertThatJson("{\"a\":1, \"b\": {\"c\" :3}}").isObject().containsValue(json("{\"c\" :\"${json-unit.any-number}\"}"));
+        assertThatJson("{\"a\":1, \"b\": {\"c\" :3}}")
+                .isObject()
+                .containsValue(json("{\"c\" :\"${json-unit.any-number}\"}"));
     }
 
     @Test
     void objectShouldContainComplexValueError() {
         assertThatThrownBy(() -> assertThatJson("{\"root\":{\"a\":1, \"b\": {\"c\" :3}}}")
-            .node("root")
-            .isObject()
-            .containsValue(json("{\"c\" :5}")))
-            .hasMessage("""
+                        .node("root")
+                        .isObject()
+                        .containsValue(json("{\"c\" :5}")))
+                .hasMessage(
+                        """
                 [Different value found in node "root"]\s
                 Expecting actual:
                   {"a":1,"b":{"c":3}}
@@ -262,17 +272,19 @@ void objectShouldContainComplexValueError() {
 
     @Test
     void objectDoesContainComplexValue() {
-        assertThatJson("{\"a\":1, \"b\": {\"c\" :3}}").isObject().doesNotContainValue(json("{\"c\" :\"${json-unit.any-string}\"}"));
+        assertThatJson("{\"a\":1, \"b\": {\"c\" :3}}")
+                .isObject()
+                .doesNotContainValue(json("{\"c\" :\"${json-unit.any-string}\"}"));
     }
 
-
     @Test
     void objectDoesContainComplexValueError() {
         assertThatThrownBy(() -> assertThatJson("{\"root\":{\"a\":1, \"b\": {\"c\" :3}}}")
-            .node("root")
-            .isObject()
-            .doesNotContainValue(json("{\"c\" :3}")))
-            .hasMessage("""
+                        .node("root")
+                        .isObject()
+                        .doesNotContainValue(json("{\"c\" :3}")))
+                .hasMessage(
+                        """
                 [Different value found in node "root"]\s
                 Expecting actual:
                   {"a":1,"b":{"c":3}}
@@ -283,26 +295,24 @@ void objectDoesContainComplexValueError() {
     @Test
     void compareJsonInJsonPathArray() {
         assertThatJson("{\"root\": [{\"target\": 450} ]}")
-            .inPath("$.root")
-            .isArray()
-            .containsExactly("{\"target\": 450 }");
+                .inPath("$.root")
+                .isArray()
+                .containsExactly("{\"target\": 450 }");
     }
 
     @Test
     void compareJsonInJsonPathShallowArray() {
-        assertThatJson("{\"root\": [450]}")
-            .inPath("$.root")
-            .isArray()
-            .containsExactly(json("450"));
+        assertThatJson("{\"root\": [450]}").inPath("$.root").isArray().containsExactly(json("450"));
     }
 
     @Test
     void compareJsonInJsonPathShallowArrayString() {
         assertThatThrownBy(() -> assertThatJson("{\"root\": [450]}")
-            .inPath("$.root")
-            .isArray()
-            .containsExactly(value("450")))
-            .hasMessage("""
+                        .inPath("$.root")
+                        .isArray()
+                        .containsExactly(value("450")))
+                .hasMessage(
+                        """
                 [Node "$.root"]\s
                 Expecting actual:
                   [450]
@@ -318,69 +328,60 @@ to contain exactly (and in same order):
     @Test
     void compareJsonInPathArrayOfArrays() {
         assertThatJson("{\"root\": [[{\"target\": 450} ]]}")
-            .inPath("$.root")
-            .isArray()
-            .containsExactly("[{\"target\": 450 }]");
+                .inPath("$.root")
+                .isArray()
+                .containsExactly("[{\"target\": 450 }]");
     }
 
     @Test
     void compareJsonInNodeArray() {
         assertThatJson("{\"root\": [{\"target\": 450} ]}")
-            .node("root")
-            .isArray()
-            .containsExactly("{\"target\": 450 }");
+                .node("root")
+                .isArray()
+                .containsExactly("{\"target\": 450 }");
     }
 
     @Test
     void compareJsonInNodeShallowArray() {
-        assertThatJson("{\"root\": [450]}")
-            .node("root")
-            .isArray()
-            .containsExactly(valueOf(450));
+        assertThatJson("{\"root\": [450]}").node("root").isArray().containsExactly(valueOf(450));
     }
 
     @Test
     void compareJsonInNodeShallowArrayBigDecimal() {
-        assertThatJson("{\"root\": [450]}")
-            .node("root")
-            .isArray()
-            .containsExactly(valueOf(450));
+        assertThatJson("{\"root\": [450]}").node("root").isArray().containsExactly(valueOf(450));
     }
 
     @Test
     void compareJsonInNodeShallowArrayBoolean() {
-        assertThatJson("{\"root\": [true]}")
-            .node("root")
-            .isArray()
-            .containsExactly(true);
+        assertThatJson("{\"root\": [true]}").node("root").isArray().containsExactly(true);
     }
 
     @Test
     void compareJsonInNodeArrayOfArrays() {
         assertThatJson("{\"root\": [[{\"target\": 450} ]]}")
-            .node("root")
-            .isArray()
-            .containsExactly("[{\"target\": 450 }]");
+                .node("root")
+                .isArray()
+                .containsExactly("[{\"target\": 450 }]");
     }
 
     @Test
     void compareJsonArray() {
         assertThatJson("{\"root\": [{\"target\": 450} ]}")
-            .node("root")
-            .isEqualTo(singletonList(singletonMap("target", 450)));
+                .node("root")
+                .isEqualTo(singletonList(singletonMap("target", 450)));
     }
 
     @Test
     void shouldAssertDirectEqual() {
-        assertThatJson("{\"a\":1}")
-            .isEqualTo("{\"a\":\"${json-unit.ignore}\"}");
+        assertThatJson("{\"a\":1}").isEqualTo("{\"a\":\"${json-unit.ignore}\"}");
     }
 
     @Test
     void shouldIgnoreIfMissing() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"root\":{\"test\":1}}").isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore}\"}}")
-        ).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":1}}")
+                        .isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore}\"}}"))
+                .hasMessage(
+                        """
             JSON documents are different:
             Different keys found in node "root", missing: "root.ignored", expected: <{"ignored":"${json-unit.ignore}","test":1}> but was: <{"test":1}>
             """);
@@ -388,33 +389,42 @@ void shouldIgnoreIfMissing() {
 
     @Test
     void shouldIgnoreIfNull() {
-        assertThatJson("{\"root\":{\"test\":1, \"ignored\": null}}").isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore}\"}}");
+        assertThatJson("{\"root\":{\"test\":1, \"ignored\": null}}")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore}\"}}");
     }
 
     @Test
     void shouldIgnoreIfObject() {
-        assertThatJson("{\"root\":{\"test\":1, \"ignored\": {\"a\": 1}}}").isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore}\"}}");
+        assertThatJson("{\"root\":{\"test\":1, \"ignored\": {\"a\": 1}}}")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore}\"}}");
     }
 
     @Test
     void shouldIgnoreElementIfMissing() {
-        assertThatJson("{\"root\":{\"test\":1}}").isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore-element}\"}}");
+        assertThatJson("{\"root\":{\"test\":1}}")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore-element}\"}}");
     }
 
     @Test
     void shouldIgnoreElementIfNull() {
-        assertThatJson("{\"root\":{\"test\":1, \"ignored\": null}}").isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore-element}\"}}");
+        assertThatJson("{\"root\":{\"test\":1, \"ignored\": null}}")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore-element}\"}}");
     }
 
     @Test
     void shouldIgnoreElementIfObject() {
-        assertThatJson("{\"root\":{\"test\":1, \"ignored\": {\"a\": 1}}}").isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore-element}\"}}");
+        assertThatJson("{\"root\":{\"test\":1, \"ignored\": {\"a\": 1}}}")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": \"${json-unit.ignore-element}\"}}");
     }
 
     @Test
     void shouldAssertObjectJson() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").node("a").isObject().isEqualTo(json("{\"b\": 2}")))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
+                        .node("a")
+                        .isObject()
+                        .isEqualTo(json("{\"b\": 2}")))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "a.b", expected: <2> but was: <1>.
                 """);
@@ -427,8 +437,12 @@ void shouldAssertContainsEntry() {
 
     @Test
     void shouldAssertContainsJsonError() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").node("a").isObject().contains(entry("b", valueOf(2))))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
+                        .node("a")
+                        .isObject()
+                        .contains(entry("b", valueOf(2))))
+                .hasMessage(
+                        """
                 [Different value found in node "a"]\s
                 Expecting map:
                   {"b":1}
@@ -446,8 +460,12 @@ void shouldAssertContainsOnlyKeys() {
 
     @Test
     void shouldAssertContainsOnlyKeysError() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1, \"c\": true}}").node("a").isObject().containsOnlyKeys("b", "c", "d"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1, \"c\": true}}")
+                        .node("a")
+                        .isObject()
+                        .containsOnlyKeys("b", "c", "d"))
+                .hasMessage(
+                        """
                 [Different value found in node "a"]\s
                 Expecting actual:
                   {"b":1,"c":true}
@@ -460,13 +478,20 @@ void shouldAssertContainsOnlyKeysError() {
 
     @Test
     void shouldAssertContainsAllEntries() {
-        assertThatJson("{\"a\":{\"b\": 1, \"c\": true}}").node("a").isObject().containsAllEntriesOf(singletonMap("c", true));
+        assertThatJson("{\"a\":{\"b\": 1, \"c\": true}}")
+                .node("a")
+                .isObject()
+                .containsAllEntriesOf(singletonMap("c", true));
     }
 
     @Test
     void shouldAssertContainsAllEntriesError() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1, \"c\": true}}").node("a").isObject().containsAllEntriesOf(singletonMap("c", false)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1, \"c\": true}}")
+                        .node("a")
+                        .isObject()
+                        .containsAllEntriesOf(singletonMap("c", false)))
+                .hasMessage(
+                        """
                 [Different value found in node "a"]\s
                 Expecting map:
                   {"b":1,"c":true}
@@ -480,7 +505,8 @@ void shouldAssertContainsAllEntriesError() {
     @Test
     void shouldAssertJson() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").node("a").isEqualTo(json("{\"b\": 2}")))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "a.b", expected: <2> but was: <1>.
                 """);
@@ -488,18 +514,28 @@ void shouldAssertJson() {
 
     @Test
     void shouldAssertObjectJsonWithPlaceholder() {
-        assertThatJson("{\"a\":{\"b\": \"ignored\"}}").node("a").isObject().isEqualTo(json("{\"b\":\"${json-unit.any-string}\"}"));
+        assertThatJson("{\"a\":{\"b\": \"ignored\"}}")
+                .node("a")
+                .isObject()
+                .isEqualTo(json("{\"b\":\"${json-unit.any-string}\"}"));
     }
 
     @Test
     void shouldAssertObjectIsNotEqualToJsonWithPlaceholder() {
-        assertThatJson("{\"a\":{\"b\": 1}}").node("a").isObject().isNotEqualTo(json("{\"b\":\"${json-unit.any-string}\"}"));
+        assertThatJson("{\"a\":{\"b\": 1}}")
+                .node("a")
+                .isObject()
+                .isNotEqualTo(json("{\"b\":\"${json-unit.any-string}\"}"));
     }
 
     @Test
     void shouldAssertObjectIsNotEqualToJsonWithPlaceholderError() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": \"string\"}}").node("a").isObject().isNotEqualTo(json("{\"b\":\"${json-unit.any-string}\"}")))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": \"string\"}}")
+                        .node("a")
+                        .isObject()
+                        .isNotEqualTo(json("{\"b\":\"${json-unit.any-string}\"}")))
+                .hasMessage(
+                        """
                 [Different value found in node "a"]\s
                 Expecting actual:
                   {"b":"string"}
@@ -510,8 +546,12 @@ void shouldAssertObjectIsNotEqualToJsonWithPlaceholderError() {
 
     @Test
     void shouldAssertObjectJsonWithPlaceholderFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").node("a").isObject().isEqualTo(json("{\"b\":\"${json-unit.any-string}\"}")))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
+                        .node("a")
+                        .isObject()
+                        .isEqualTo(json("{\"b\":\"${json-unit.any-string}\"}")))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "a.b", expected: <a string> but was: <1>.
                 """);
@@ -519,8 +559,12 @@ void shouldAssertObjectJsonWithPlaceholderFailure() {
 
     @Test
     void shouldAssertString() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": \"foo\"}}").node("a.b").isString().startsWith("bar"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": \"foo\"}}")
+                        .node("a.b")
+                        .isString()
+                        .startsWith("bar"))
+                .hasMessage(
+                        """
                 [Different value found in node "a.b"]\s
                 Expecting actual:
                   "foo"
@@ -531,8 +575,13 @@ void shouldAssertString() {
 
     @Test
     void shouldAssertStringCustomDescription() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": \"foo\"}}").node("a.b").isString().as("Sad!").startsWith("bar"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": \"foo\"}}")
+                        .node("a.b")
+                        .isString()
+                        .as("Sad!")
+                        .startsWith("bar"))
+                .hasMessage(
+                        """
                 [Sad!]\s
                 Expecting actual:
                   "foo"
@@ -548,38 +597,51 @@ void shouldAssertArray() {
 
     @Test
     void shouldFindObjectInArray() {
-        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").node("a").isArray().contains(json("{\"c\": 1}"));
+        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                .node("a")
+                .isArray()
+                .contains(json("{\"c\": 1}"));
     }
 
     @Test
     void shouldFindObjectInArrayWithPlaceholder() {
-        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").node("a").isArray().contains(json("{\"c\": \"${json-unit.any-number}\"}"));
+        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                .node("a")
+                .isArray()
+                .contains(json("{\"c\": \"${json-unit.any-number}\"}"));
     }
 
     @Test
     void arraySimpleIgnoringOrderComparisonExample() {
-        assertThatJson("{\"test\":[1,2,3]}")
-            .when(IGNORING_ARRAY_ORDER)
-            .isEqualTo("{\"test\":[3,2,1]}");
+        assertThatJson("{\"test\":[1,2,3]}").when(IGNORING_ARRAY_ORDER).isEqualTo("{\"test\":[3,2,1]}");
     }
 
     @Test
     void arrayIgnoringOrderComparison() {
-        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").node("a").isArray()
-            .containsExactlyInAnyOrder(json("{\"c\": 1}"), json("{\"b\": 1}"), json("{\"d\": 1}"));
+        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                .node("a")
+                .isArray()
+                .containsExactlyInAnyOrder(json("{\"c\": 1}"), json("{\"b\": 1}"), json("{\"d\": 1}"));
     }
 
     @Test
     void arraySimpleIgnoringOrderComparison() {
-        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").when(Option.IGNORING_ARRAY_ORDER).node("a").isArray()
-            .isEqualTo(json("[{\"c\": 1}, {\"b\": 1} ,{\"d\": 1}]"));
+        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                .when(Option.IGNORING_ARRAY_ORDER)
+                .node("a")
+                .isArray()
+                .isEqualTo(json("[{\"c\": 1}, {\"b\": 1} ,{\"d\": 1}]"));
     }
 
     @Test
     void arraySimpleIgnoringOrderComparisonError() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").when(Option.IGNORING_ARRAY_ORDER).node("a").isArray()
-            .isEqualTo(json("[{\"c\": 2}, {\"b\": 1} ,{\"d\": 1}]")))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                        .when(Option.IGNORING_ARRAY_ORDER)
+                        .node("a")
+                        .isArray()
+                        .isEqualTo(json("[{\"c\": 2}, {\"b\": 1} ,{\"d\": 1}]")))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element a[0] to actual element a[1].
                 Different value found in node "a[1].c", expected: <2> but was: <1>.
@@ -589,40 +651,51 @@ void arraySimpleIgnoringOrderComparisonError() {
     @Test
     void multipleFailuresErrorShouldBeCorrectlyFormatted() {
         assertThatExceptionOfType(MultipleFailuresError.class)
-            .isThrownBy(() -> assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").when(Option.IGNORING_ARRAY_ORDER).node("a").isArray()
-                .isEqualTo(json("[{\"c\": 2}, {\"b\": 1} ,{\"d\": 1}]")))
-            .satisfies(e -> {
-                List<Throwable> failures = e.getFailures();
-                assertThat(failures.get(0).getMessage()).isEqualTo("Different value found when comparing expected array element a[0] to actual element a[1].");
-                assertThat(failures.get(1).getMessage()).isEqualTo("Different value found in node \"a[1].c\", expected: <2> but was: <1>.");
-            });
+                .isThrownBy(() -> assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                        .when(Option.IGNORING_ARRAY_ORDER)
+                        .node("a")
+                        .isArray()
+                        .isEqualTo(json("[{\"c\": 2}, {\"b\": 1} ,{\"d\": 1}]")))
+                .satisfies(e -> {
+                    List<Throwable> failures = e.getFailures();
+                    assertThat(failures.get(0).getMessage())
+                            .isEqualTo(
+                                    "Different value found when comparing expected array element a[0] to actual element a[1].");
+                    assertThat(failures.get(1).getMessage())
+                            .isEqualTo("Different value found in node \"a[1].c\", expected: <2> but was: <1>.");
+                });
     }
 
     @Test
     void shouldIgnoreMissingPathEvenIfItIsInExpectedValue() {
         assertThatJson("{\"root\":{\"foo\":1}}")
-            .whenIgnoringPaths("root.bar", "missing")
-            .isEqualTo("{\"root\":{\"foo\":1, \"bar\":2}, \"missing\":{\"quux\":\"test\"}}");
+                .whenIgnoringPaths("root.bar", "missing")
+                .isEqualTo("{\"root\":{\"foo\":1, \"bar\":2}, \"missing\":{\"quux\":\"test\"}}");
     }
 
     @Test
     void shouldIgnoreArrayElement() {
-        assertThatJson("{\"root\":[0, 1, 2]}")
-            .whenIgnoringPaths("root[1]")
-            .isEqualTo("{\"root\":[0, 8, 2]}");
+        assertThatJson("{\"root\":[0, 1, 2]}").whenIgnoringPaths("root[1]").isEqualTo("{\"root\":[0, 8, 2]}");
     }
 
     @Test
     void arraySimpleIgnoringOrderNotEqualComparison() {
-        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").when(Option.IGNORING_ARRAY_ORDER).node("a").isArray()
-            .isNotEqualTo(json("[{\"c\": 2}, {\"b\": 1} ,{\"d\": 1}]"));
+        assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                .when(Option.IGNORING_ARRAY_ORDER)
+                .node("a")
+                .isArray()
+                .isNotEqualTo(json("[{\"c\": 2}, {\"b\": 1} ,{\"d\": 1}]"));
     }
 
     @Test
     void arraySimpleIgnoringOrderNotEqualComparisonError() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}").when(Option.IGNORING_ARRAY_ORDER).node("a").isArray()
-            .isNotEqualTo(json("[{\"c\": 1}, {\"b\": 1} ,{\"d\": 1}]")))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}, {\"d\": 1}]}")
+                        .when(Option.IGNORING_ARRAY_ORDER)
+                        .node("a")
+                        .isArray()
+                        .isNotEqualTo(json("[{\"c\": 1}, {\"b\": 1} ,{\"d\": 1}]")))
+                .hasMessage(
+                        """
                 [Node "a"]\s
                 Expecting:
                  <[{"b":1}, {"c":1}, {"d":1}]>
@@ -633,12 +706,13 @@ void arraySimpleIgnoringOrderNotEqualComparisonError() {
 
     @Test
     void shouldAssertBoolean() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": true}}").node("a.b").isBoolean().isFalse())
-            .hasMessage("[Different value found in node \"a.b\"] \n" +
-                "Expecting value to be false but was true");
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": true}}")
+                        .node("a.b")
+                        .isBoolean()
+                        .isFalse())
+                .hasMessage("[Different value found in node \"a.b\"] \n" + "Expecting value to be false but was true");
     }
 
-
     @Test
     void shouldAssertNull() {
         assertThatJson("{\"a\":{\"b\": null}}").node("a.b").isNull();
@@ -646,26 +720,38 @@ void shouldAssertNull() {
 
     @Test
     void shouldAssertNullFail() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").node("a.b").isNull())
-            .hasMessage("Node \"a.b\" has invalid type, expected: <null> but was: <1>.");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"a\":{\"b\": 1}}").node("a.b").isNull())
+                .hasMessage("Node \"a.b\" has invalid type, expected: <null> but was: <1>.");
     }
 
     @Test
     void shouldAssertNotNull() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": null}}").node("a.b").isNotNull())
-            .hasMessage("Node \"a.b\" has invalid type, expected: <not null> but was: <null>.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"a\":{\"b\": null}}").node("a.b").isNotNull())
+                .hasMessage("Node \"a.b\" has invalid type, expected: <not null> but was: <null>.");
     }
 
     @Test
     void shouldAssertNotNullChain() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": null}}").node("a").isPresent().node("b").isNotNull())
-            .hasMessage("Node \"a.b\" has invalid type, expected: <not null> but was: <null>.");
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": null}}")
+                        .node("a")
+                        .isPresent()
+                        .node("b")
+                        .isNotNull())
+                .hasMessage("Node \"a.b\" has invalid type, expected: <not null> but was: <null>.");
     }
 
     @Test
     void shouldAssertNotNullChaining() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").node("a").isNotNull().node("b").isNumber().isEqualByComparingTo("2"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
+                        .node("a")
+                        .isNotNull()
+                        .node("b")
+                        .isNumber()
+                        .isEqualByComparingTo("2"))
+                .hasMessage(
+                        """
                 [Different value found in node "a.b"]\s
                 expected: 2
                  but was: 1""");
@@ -674,81 +760,87 @@ void shouldAssertNotNullChaining() {
     @Test
     void shouldAssertNotNullChainingSuccess() {
         assertThatJson("{\"a\":{\"b\": 1}}")
-            .node("a")
-            .isNotNull()
-            .node("b")
-            .isNumber()
-            .isEqualByComparingTo("1");
+                .node("a")
+                .isNotNull()
+                .node("b")
+                .isNumber()
+                .isEqualByComparingTo("1");
     }
 
     @Test
     void shouldAssertUri() {
         assertThatJson("{\"a\":{\"b\":\"http://exampl.org?a=1\"}}")
-            .node("a.b")
-            .isUri().hasScheme("http").hasParameter("a", "1");
+                .node("a.b")
+                .isUri()
+                .hasScheme("http")
+                .hasParameter("a", "1");
     }
 
     @Test
     void shouldAssertUriFail() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\":\"test\"}}")
-            .node("a.b")
-            .isUri().hasScheme("http")
-        ).hasMessage("""
+                        .node("a.b")
+                        .isUri()
+                        .hasScheme("http"))
+                .hasMessage(
+                        """
             [Different value found in node "a.b"]\s
             Expecting scheme of
               <test>
             to be:
               <"http">
             but was:
-              <null>"""
-        );
+              <null>""");
     }
 
     @Test
     void shouldAssertUriFailOnType() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
-            .node("a.b")
-            .isUri()
-        ).hasMessage("Node \"a.b\" has invalid type, expected: <string> but was: <1>.");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"a\":{\"b\": 1}}").node("a.b").isUri())
+                .hasMessage("Node \"a.b\" has invalid type, expected: <string> but was: <1>.");
     }
 
     @Test
     void canNotConfigureAfterAssertion() {
         // do not want to allow this
-        //assertThatJson("[1, 2]").isEqualTo("[2, 1]").when(IGNORING_ARRAY_ORDER);
+        // assertThatJson("[1, 2]").isEqualTo("[2, 1]").when(IGNORING_ARRAY_ORDER);
     }
 
     @Test
     void shouldAssertNotNullMissing() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": null}}").node("a.c").isNotNull())
-            .hasMessage("Different value found in node \"a.c\", expected: <not null> but was: <missing>.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"a\":{\"b\": null}}").node("a.c").isNotNull())
+                .hasMessage("Different value found in node \"a.c\", expected: <not null> but was: <missing>.");
     }
 
     @Test
     void shouldAssertObjectFailure() {
         assertThatThrownBy(() -> assertThatJson("true").isObject())
-            .hasMessage("Node \"\" has invalid type, expected: <object> but was: <true>.");
+                .hasMessage("Node \"\" has invalid type, expected: <object> but was: <true>.");
     }
 
-
     @Test
     void absentInPathShouldFailOnSimpleJson() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}").inPath("$.a.b").isAbsent())
-            .hasMessage("Different value found in node \"$.a.b\", expected: <node to be absent> but was: <1>.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"a\":{\"b\": 1}}").inPath("$.a.b").isAbsent())
+                .hasMessage("Different value found in node \"$.a.b\", expected: <node to be absent> but was: <1>.");
     }
 
     @Test
     void absentInPathShouldFailOnArray() {
-        assertThatThrownBy(() -> assertThatJson("[{\"b\": 1}, {\"c\": 1}]").inPath("[*].c").isAbsent())
-            .hasMessage("Different value found in node \"$[1].c\", expected: <node to be absent> but was: <[1]>.");
+        assertThatThrownBy(() -> assertThatJson("[{\"b\": 1}, {\"c\": 1}]")
+                        .inPath("[*].c")
+                        .isAbsent())
+                .hasMessage("Different value found in node \"$[1].c\", expected: <node to be absent> but was: <[1]>.");
     }
 
-
     @Test
     void absentInPathShouldFailOnMultipleMatches() {
         assertThatThrownBy(() -> assertThatJson("[{\"c\": {\"x\": 2}}, {\"b\": {\"x\": 2}}, {\"c\": {\"x\": 2}}]")
-            .inPath("$.[*].c").isAbsent())
-            .hasMessage("Different value found in nodes \"[$[0].c, $[2].c]\", expected: <node to be absent> but was: <[{\"x\":2},{\"x\":2}]>.");
+                        .inPath("$.[*].c")
+                        .isAbsent())
+                .hasMessage(
+                        "Different value found in nodes \"[$[0].c, $[2].c]\", expected: <node to be absent> but was: <[{\"x\":2},{\"x\":2}]>.");
     }
 
     @Test
@@ -771,38 +863,37 @@ void shouldAssertInteger() {
 
     @Test
     void shouldAllowNodeInJsonMapAssert() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"data\":{\"id\": \"1234\", \"relationships\": false}}")
-            .inPath("$.data")
-            .isObject()
-            .containsEntry("id", "1234")
-            .node("relationships")
-            .isObject()
-        ).hasMessage("Node \"$.data.relationships\" has invalid type, expected: <object> but was: <false>.");
+        assertThatThrownBy(() -> assertThatJson("{\"data\":{\"id\": \"1234\", \"relationships\": false}}")
+                        .inPath("$.data")
+                        .isObject()
+                        .containsEntry("id", "1234")
+                        .node("relationships")
+                        .isObject())
+                .hasMessage("Node \"$.data.relationships\" has invalid type, expected: <object> but was: <false>.");
     }
 
     @Test
     void shouldAssertIntegerFailure() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":1.0}").node("a").isIntegralNumber())
-            .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <1.0>.");
+                .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <1.0>.");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":0.0}").node("a").isIntegralNumber())
-            .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <0.0>.");
+                .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <0.0>.");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":10.0}").node("a").isIntegralNumber())
-            .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <10.0>.");
+                .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <10.0>.");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":-10.0}").node("a").isIntegralNumber())
-            .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <-10.0>.");
+                .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <-10.0>.");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":1.1}").node("a").isIntegralNumber())
-            .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <1.1>.");
+                .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <1.1>.");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":1e3}").node("a").isIntegralNumber())
-            .hasMessageStartingWith("Node \"a\" has invalid type, expected: <integer> but was:");
+                .hasMessageStartingWith("Node \"a\" has invalid type, expected: <integer> but was:");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":1e-3}").node("a").isIntegralNumber())
-            .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <0.001>.");
+                .hasMessage("Node \"a\" has invalid type, expected: <integer> but was: <0.001>.");
     }
 
     @Test
@@ -816,19 +907,21 @@ protected void shouldUseCustomNumberComparator() {
             }
         };
         assertThatJson("{\"a\":1.0}")
-            .withConfiguration(c -> c.withNumberComparator(numberComparator))
-            .isEqualTo("{\"a\":1.00}");
+                .withConfiguration(c -> c.withNumberComparator(numberComparator))
+                .isEqualTo("{\"a\":1.00}");
 
         assertThatThrownBy(() -> assertThatJson("{\"a\":1.0}")
-            .withConfiguration(c -> c.withNumberComparator(numberComparator))
-            .isEqualTo("{\"a\":1}")).hasMessage("JSON documents are different:\nDifferent value found in node \"a\", expected: <1> but was: <1.0>.\n");
+                        .withConfiguration(c -> c.withNumberComparator(numberComparator))
+                        .isEqualTo("{\"a\":1}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"a\", expected: <1> but was: <1.0>.\n");
     }
 
     @Test
     @Disabled
     protected void shouldAssert1e0() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":1e0}").node("a").isIntegralNumber())
-            .hasMessageStartingWith("Node \"a\" has invalid type, expected: <integer> but was:");
+                .hasMessageStartingWith("Node \"a\" has invalid type, expected: <integer> but was:");
     }
 
     @Test
@@ -838,28 +931,31 @@ protected void shouldFailOnTrainingToken() {
 
     @Test
     void arrayExtractingShouldPass() {
-        assertThatJson("""
+        assertThatJson(
+                        """
             [
                   {"id": 1, "name":{"first":"Aaron"}},
                   {"id": 2, "name":{"first":"Paul"}}
                 ]""")
-            .isArray()
-            .extracting("id", "name")
-            .contains(tuple(valueOf(1), "{\"first\":\"Aaron\"}"), tuple(valueOf(2), "{\"first\":\"Paul\"}"));
+                .isArray()
+                .extracting("id", "name")
+                .contains(tuple(valueOf(1), "{\"first\":\"Aaron\"}"), tuple(valueOf(2), "{\"first\":\"Paul\"}"));
     }
 
     @Test
     void arrayExtractingShouldFail() {
-        assertThatThrownBy(() ->
-            assertThatJson("""
+        assertThatThrownBy(() -> assertThatJson(
+                                """
                 [
                       {"id": 1, "name":{"first":"Aaron"}},
                       {"id": 2, "name":{"first":"John"}}
                     ]""")
-                .isArray()
-                .extracting("id", "name")
-                .contains(tuple(valueOf(1), "{\"first\":\"Aaron\"}"), tuple(valueOf(2), "{\"first\":\"Paul\"}"))
-        ).hasMessage("""
+                        .isArray()
+                        .extracting("id", "name")
+                        .contains(
+                                tuple(valueOf(1), "{\"first\":\"Aaron\"}"), tuple(valueOf(2), "{\"first\":\"Paul\"}")))
+                .hasMessage(
+                        """
             [Node ""]\s
             Expecting ArrayList:
               [(1, {"first":"Aaron"}), (2, {"first":"John"})]
@@ -872,16 +968,19 @@ but could not find the following element(s):
 
     @Test
     void arrayExtractingShouldFailOnDifferentLengthTuple() {
-        assertThatThrownBy(() ->
-        assertThatJson("""
+        assertThatThrownBy(() -> assertThatJson(
+                                """
             [
                   {"id": 1, "name":{"first":"Aaron"}},
                   {"id": 2, "name":{"first":"John"}}
                 ]""")
-            .isArray()
-            .extracting("id", "name")
-            .contains(tuple(valueOf(1), "{\"first\":\"Aaron\"}", 3), tuple(valueOf(2), "{\"first\":\"John\"}"))
-        ).hasMessage("""
+                        .isArray()
+                        .extracting("id", "name")
+                        .contains(
+                                tuple(valueOf(1), "{\"first\":\"Aaron\"}", 3),
+                                tuple(valueOf(2), "{\"first\":\"John\"}")))
+                .hasMessage(
+                        """
             [Node ""]\s
             Expecting ArrayList:
               [(1, {"first":"Aaron"}), (2, {"first":"John"})]
@@ -895,21 +994,26 @@ but could not find the following element(s):
     @Test
     void shouldNotParseTwice() {
         String result = "{\"bundles\":[\"http://localhost:33621/rms/framework/bundle/0\"]}";
-        assertThatJson(result).and(
-            JsonAssert::isObject,
-            j -> j.node("bundles").isArray().element(0).asString().contains("http://", "/framework/bundle/0")
-        );
+        assertThatJson(result).and(JsonAssert::isObject, j -> j.node("bundles")
+                .isArray()
+                .element(0)
+                .asString()
+                .contains("http://", "/framework/bundle/0"));
     }
 
     @Test
     void elementWithTypeAssertShouldWork() {
         String result = "{\"bundles\":[\"http://localhost:33621/rms/framework/bundle/0\"]}";
         // FIXME: Better path in the message
-        assertThatThrownBy(() -> assertThatJson(result).node("bundles").isArray().element(0).isNumber())
-            .hasMessage("Node \"bundles\" element at index 0 has invalid type, expected: <number> but was: <\"http://localhost:33621/rms/framework/bundle/0\">.");
+        assertThatThrownBy(() -> assertThatJson(result)
+                        .node("bundles")
+                        .isArray()
+                        .element(0)
+                        .isNumber())
+                .hasMessage(
+                        "Node \"bundles\" element at index 0 has invalid type, expected: <number> but was: <\"http://localhost:33621/rms/framework/bundle/0\">.");
     }
 
-
     @Test
     void shouldAssertStringNumber() {
         assertThatJson("{\"a\":\"1\"}").node("a").asNumber().isEqualByComparingTo("1");
@@ -917,33 +1021,33 @@ void shouldAssertStringNumber() {
 
     @Test
     void shouldAssertStringNumberFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":\"x\"}").node("a").asNumber().isEqualByComparingTo("1"))
-            .hasMessage("Node \"a\" can not be converted to number expected: <a number> but was: <\"x\">.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"a\":\"x\"}").node("a").asNumber().isEqualByComparingTo("1"))
+                .hasMessage("Node \"a\" can not be converted to number expected: <a number> but was: <\"x\">.");
     }
 
     @Test
     protected void shouldDiffCloseNumbers() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"result\":{\"a\": 0.299999999999999988897769753748434595763683319091796875}}").isEqualTo("{result: {a: 0.3}}")
-        );
+        assertThatThrownBy(
+                () -> assertThatJson("{\"result\":{\"a\": 0.299999999999999988897769753748434595763683319091796875}}")
+                        .isEqualTo("{result: {a: 0.3}}"));
     }
 
     // https://github.com/assertj/assertj-core/issues/2111
     @Test
     void containsValue() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\": 1}")
-            .isObject().containsKey("lastModified2"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\": 1}").isObject().containsKey("lastModified2"))
+                .hasMessage(
+                        """
                 [Different value found in node ""]\s
                 Expecting actual:
                   {"a":1}
                 to contain key:
                   "lastModified2\"""");
 
-        assertThatThrownBy(() ->
-            assertThatJson("{\"a\": 1}")
-                .isObject().contains(entry("lastModified2", null)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\": 1}").isObject().contains(entry("lastModified2", null)))
+                .hasMessage(
+                        """
                 [Different value found in node ""]\s
                 Expecting map:
                   {"a":1}
@@ -956,14 +1060,15 @@ void containsValue() {
 
     @Test
     void shouldAssertNumberFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":1}").node("a").isNumber().isEqualByComparingTo("2"))
-            .hasMessage("""
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"a\":1}").node("a").isNumber().isEqualByComparingTo("2"))
+                .hasMessage(
+                        """
                 [Different value found in node "a"]\s
                 expected: 2
                  but was: 1""");
     }
 
-
     @Test
     void testAssertToleranceSimple() {
         assertThatJson("{\"test\":1.00001}").withTolerance(0.001).isEqualTo("{\"test\":1}");
@@ -971,16 +1076,23 @@ void testAssertToleranceSimple() {
 
     @Test
     void testAssertTolerance() {
-        assertThatJson("{\"test\":1.00001}").withConfiguration(c -> c.withTolerance(0.001)).isEqualTo("{\"test\":1}");
+        assertThatJson("{\"test\":1.00001}")
+                .withConfiguration(c -> c.withTolerance(0.001))
+                .isEqualTo("{\"test\":1}");
     }
 
     @Test
     void shouldFailCorrectlyOnMissingNode() {
         assertThatThrownBy(() -> assertThatJson("[{\"a\":\"01\", \"b\":\"text\"}]")
-            .node("[0].a").isEqualTo("\"01\"")
-            .node("[0].b").isEqualTo("text"))
-            .hasMessage("JSON documents are different:\nMissing node in path \"[0].a[0].b\".\n")
-            .matches(e -> ((AssertionFailedError)e).getActual().getStringRepresentation().equals("<missing>"));
+                        .node("[0].a")
+                        .isEqualTo("\"01\"")
+                        .node("[0].b")
+                        .isEqualTo("text"))
+                .hasMessage("JSON documents are different:\nMissing node in path \"[0].a[0].b\".\n")
+                .matches(e -> ((AssertionFailedError) e)
+                        .getActual()
+                        .getStringRepresentation()
+                        .equals("<missing>"));
     }
 
     @Test
@@ -991,70 +1103,87 @@ public void shouldAllowUnquotedKeysAndCommentInExpectedValue() {
     @Test
     void testAssertNode() {
         assertThatThrownBy(() -> assertThatJson(readValue("{\"test\":1}")).isEqualTo(readValue("{\"test\":2}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertNodeInExpectOnly() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").isEqualTo(readValue("{\"test\":2}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertPathWithDescription() {
-        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$")).node("test").isEqualTo("2"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"$.test\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$"))
+                        .node("test")
+                        .isEqualTo("2"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"$.test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testPresentWithDescription() {
-        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$")).node("test2").isPresent())
-            .hasMessage("Different value found in node \"$.test2\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$"))
+                        .node("test2")
+                        .isPresent())
+                .hasMessage(
+                        "Different value found in node \"$.test2\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
     protected void testNotEqualTo() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").isNotEqualTo("{\"test\": \"${json-unit.any-number}\"}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expecting actual:
                   {"test":1}
                 not to be equal to:
                   "{"test": "${json-unit.any-number}"}"
                 when comparing values using JsonComparator""");
-
     }
 
     @Test
     void testAssertPathArray() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[0]").isEqualTo(2))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"root.test[0]\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                        .node("root.test[0]")
+                        .isEqualTo(2))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"root.test[0]\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testLongRegexp() {
         assertThatJson("{\"test\": \"This is some text followed by: ABCD, followed by this\"}")
-            .isEqualTo("{\"test\": \"${json-unit.regex}^\\\\QThis is some text followed by: \\\\E[A-Z]+\\\\Q, followed by this\\\\E$\"}");
+                .isEqualTo(
+                        "{\"test\": \"${json-unit.regex}^\\\\QThis is some text followed by: \\\\E[A-Z]+\\\\Q, followed by this\\\\E$\"}");
     }
 
     @Test
     void testLongRegexpBuilder() {
         assertThatJson("{\"test\": \"This is some text followed by: ABCD, followed by this\"}")
-            .isEqualTo("{\"test\": " + regex().str("This is some text followed by: ").exp("[A-Z]+").str(", followed by this") + "}");
+                .isEqualTo("{\"test\": "
+                        + regex().str("This is some text followed by: ")
+                                .exp("[A-Z]+")
+                                .str(", followed by this") + "}");
     }
 
     @Test
     public void verifyIsArrayContainsString() {
         assertThatJson("{\"id\":\"1\", \"children\":[{\"parentId\":\"1\"}]}")
-            .inPath("children[*].parentId")
-            .isArray()
-            .containsOnly(value("1"));
+                .inPath("children[*].parentId")
+                .isArray()
+                .containsOnly(value("1"));
     }
 
     @Test
     void testNodeAbsent() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}").node("test2").isAbsent())
-            .hasMessage("Different value found in node \"test2\", expected: <node to be absent> but was: <1>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}")
+                        .node("test2")
+                        .isAbsent())
+                .hasMessage("Different value found in node \"test2\", expected: <node to be absent> but was: <1>.");
     }
 
     @Test
@@ -1065,19 +1194,25 @@ void testNodeAbsentOk() {
     @Test
     void shouldTreatNullAsAbsent() {
         assertThatJson("{\"a\":1, \"b\": null}")
-            .when(Option.TREATING_NULL_AS_ABSENT).node("b").isAbsent();
+                .when(Option.TREATING_NULL_AS_ABSENT)
+                .node("b")
+                .isAbsent();
     }
 
     @Test
     void shouldNotTreatNullAsAbsent() {
-        assertThatThrownBy(() -> assertThatJson("{\"a\":1, \"b\": null}").node("b").isAbsent())
-            .hasMessage("Different value found in node \"b\", expected: <node to be absent> but was: <null>.");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"a\":1, \"b\": null}").node("b").isAbsent())
+                .hasMessage("Different value found in node \"b\", expected: <node to be absent> but was: <null>.");
     }
 
     @Test
     void testNodePresent() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}").node("test3").isPresent())
-            .hasMessage("Different value found in node \"test3\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}")
+                        .node("test3")
+                        .isPresent())
+                .hasMessage(
+                        "Different value found in node \"test3\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -1087,10 +1222,9 @@ void testNodePresentOk() {
 
     @Test
     void testAnd() {
-        assertThatJson("{\"test1\":2, \"test2\":1}",
-            json -> json.inPath("test1").isEqualTo(2),
-            json -> json.inPath("test2").isEqualTo(1)
-        );
+        assertThatJson(
+                "{\"test1\":2, \"test2\":1}", json -> json.inPath("test1").isEqualTo(2), json -> json.inPath("test2")
+                        .isEqualTo(1));
     }
 
     @Test
@@ -1100,31 +1234,42 @@ void testNodePresentNull() {
 
     @Test
     void isPresentShouldTreatNullAsAbsentWhenSpecified() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":null}").when(Option.TREATING_NULL_AS_ABSENT).node("test2").isPresent())
-            .hasMessage("Different value found in node \"test2\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":null}")
+                        .when(Option.TREATING_NULL_AS_ABSENT)
+                        .node("test2")
+                        .isPresent())
+                .hasMessage(
+                        "Different value found in node \"test2\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
     void testMessage() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":1}").as("Test is different").isEqualTo("{\"test\":2}"))
-            .hasMessage("[Test is different] JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":1}").as("Test is different").isEqualTo("{\"test\":2}"))
+                .hasMessage(
+                        "[Test is different] JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testIgnoreDifferent() {
-        assertThatJson("{\"test\":1}").withConfiguration(c -> c.withIgnorePlaceholder("##IGNORE##")).isEqualTo("{\"test\":\"##IGNORE##\"}");
+        assertThatJson("{\"test\":1}")
+                .withConfiguration(c -> c.withIgnorePlaceholder("##IGNORE##"))
+                .isEqualTo("{\"test\":\"##IGNORE##\"}");
     }
 
     @Test
     void anyNumberShouldFailOnNull() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":null}").isEqualTo("{\"test\":\"${json-unit.any-number}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <null>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <null>.\n");
     }
 
     @Test
     void anyNumberShouldFailOnObject() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-number}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <{\"a\":1}>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-number}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <{\"a\":1}>.\n");
     }
 
     @Test
@@ -1146,13 +1291,15 @@ void emptinessCheck2() {
     void ifMatcherDoesNotMatchReportDifference() {
         RecordingDifferenceListener listener = new RecordingDifferenceListener();
         assertThatThrownBy(() -> assertThatJson("{\"test\":-1}")
-            .withMatcher("positive", greaterThan(valueOf(0)))
-            .withDifferenceListener(listener)
-            .isEqualTo("{\"test\": \"${json-unit.matches:positive}\"}"))
-            .hasMessage("JSON documents are different:\nMatcher \"positive\" does not match value -1 in node \"test\". <-1> was less than <0>\n");
+                        .withMatcher("positive", greaterThan(valueOf(0)))
+                        .withDifferenceListener(listener)
+                        .isEqualTo("{\"test\": \"${json-unit.matches:positive}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nMatcher \"positive\" does not match value -1 in node \"test\". <-1> was less than <0>\n");
 
         assertThat(listener.getDifferenceList()).hasSize(1);
-        assertThat(listener.getDifferenceList().get(0).toString()).isEqualTo("DIFFERENT Expected ${json-unit.matches:positive} in test got -1 in test");
+        assertThat(listener.getDifferenceList().get(0).toString())
+                .isEqualTo("DIFFERENT Expected ${json-unit.matches:positive} in test got -1 in test");
     }
 
     @Test
@@ -1160,39 +1307,44 @@ void parametrizedMatcherShouldFail() {
         Matcher<?> divisionMatcher = new DivisionMatcher();
         try {
             assertThatJson("{\"test\":5}")
-                .withMatcher("isDivisibleBy", divisionMatcher)
-                .isEqualTo("{\"test\": \"${json-unit.matches:isDivisibleBy}3\"}");
+                    .withMatcher("isDivisibleBy", divisionMatcher)
+                    .isEqualTo("{\"test\": \"${json-unit.matches:isDivisibleBy}3\"}");
         } catch (AssertionError e) {
-            assertEquals("JSON documents are different:\nMatcher \"isDivisibleBy\" does not match value 5 in node \"test\". It is not divisible by <3>\n", e.getMessage());
+            assertEquals(
+                    "JSON documents are different:\nMatcher \"isDivisibleBy\" does not match value 5 in node \"test\". It is not divisible by <3>\n",
+                    e.getMessage());
         }
     }
 
     @Test
     void shoulEscapeDot() {
-        assertThatJson("{\"name.with.dot\": \"value\"}").node("name\\.with\\.dot").isEqualTo("value");
+        assertThatJson("{\"name.with.dot\": \"value\"}")
+                .node("name\\.with\\.dot")
+                .isEqualTo("value");
     }
 
     @Test
     void pathShouldBeIgnoredForExtraKey() {
         assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}")
-            .withConfiguration(c -> c.whenIgnoringPaths("root.ignored"))
-            .isEqualTo("{\"root\":{\"test\":1}}");
+                .withConfiguration(c -> c.whenIgnoringPaths("root.ignored"))
+                .isEqualTo("{\"root\":{\"test\":1}}");
     }
 
     @Test
     void withFailMessageShouldWork() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
-            .withFailMessage("It's broken")
-            .isEqualTo("{\"b\": 2}")
-        ).hasMessage("It's broken");
+                        .withFailMessage("It's broken")
+                        .isEqualTo("{\"b\": 2}"))
+                .hasMessage("It's broken");
     }
 
     @Test
     void describedAsShouldWork() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":{\"b\": 1}}")
-            .describedAs("It's broken")
-            .isEqualTo("{\"b\": 2}")
-        ).hasMessage("""
+                        .describedAs("It's broken")
+                        .isEqualTo("{\"b\": 2}"))
+                .hasMessage(
+                        """
             [It's broken] JSON documents are different:
             Different keys found in node "", missing: "b", extra: "a", expected: <{"b":2}> but was: <{"a":{"b":1}}>
             """);
@@ -1201,18 +1353,17 @@ void describedAsShouldWork() {
     @Test
     void pathShouldBeIgnoredForDifferentValue() {
         assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}")
-            .whenIgnoringPaths("root.ignored")
-            .isEqualTo("{\"root\":{\"test\":1, \"ignored\": 2}}");
+                .whenIgnoringPaths("root.ignored")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": 2}}");
     }
 
     @Test
     void pathShouldBeIgnoredForArrayExample() {
         assertThatJson("[{\"a\":1, \"b\":2},{\"a\":1, \"b\":3}]")
-            .whenIgnoringPaths("[*].b")
-            .isEqualTo("[{\"a\":1, \"b\":0},{\"a\":1, \"b\":0}]");
+                .whenIgnoringPaths("[*].b")
+                .isEqualTo("[{\"a\":1, \"b\":0},{\"a\":1, \"b\":0}]");
     }
 
-
     private static class TestBean {
         final BigDecimal demo;
 
@@ -1234,26 +1385,26 @@ protected void shouldEqualNumberInObject() {
 
     @Test
     void testEqualsToArray() {
-        assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo(new int[]{1, 2, 3});
+        assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo(new int[] {1, 2, 3});
     }
 
     @Test
     void assertContainsEntryNumber() {
         assertThatJson("{\"a\":1, \"b\":2.0}")
-            .withTolerance(0)
-            .isObject()
-            .containsEntry("a", 1)
-            .containsEntry("b", 2);
+                .withTolerance(0)
+                .isObject()
+                .containsEntry("a", 1)
+                .containsEntry("b", 2);
     }
 
     @Test
     protected void assertContainsEntryNumberFailure() {
-        assertThatThrownBy(() ->
-        assertThatJson("{\"a\":1, \"b\":2.0}")
-            .isObject()
-            .containsEntry("a", 1)
-            .containsEntry("b", 2)
-        ).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":1, \"b\":2.0}")
+                        .isObject()
+                        .containsEntry("a", 1)
+                        .containsEntry("b", 2))
+                .hasMessage(
+                        """
             [Different value found in node ""]\s
             Expecting map:
               {"a":1,"b":2.0}
@@ -1271,40 +1422,48 @@ void testEqualsToList() {
 
     @Test
     void testEqualsToObjectList() {
-        assertThatJson("{\"test\":[{\"a\":1}, {\"b\":2}]}").node("test").isEqualTo(asList(readValue("{\"a\":1}"), readValue("{\"b\":2}")));
+        assertThatJson("{\"test\":[{\"a\":1}, {\"b\":2}]}")
+                .node("test")
+                .isEqualTo(asList(readValue("{\"a\":1}"), readValue("{\"b\":2}")));
     }
 
     @Test
     void testEqualsToDoubleArray() {
-        assertThatJson("{\"test\":[1.0,2.0,3.0]}").node("test").isEqualTo(new double[]{1, 2, 3});
+        assertThatJson("{\"test\":[1.0,2.0,3.0]}").node("test").isEqualTo(new double[] {1, 2, 3});
     }
 
     @Test
     void testEqualsToBooleanArray() {
-        assertThatJson("{\"test\":[true, false]}").node("test").isEqualTo(new boolean[]{true, false});
+        assertThatJson("{\"test\":[true, false]}").node("test").isEqualTo(new boolean[] {true, false});
     }
 
     @Test
     void testEqualsToObjectArray() {
-        assertThatJson("{\"test\":[{\"a\":1}, {\"b\":2}]}").node("test").isEqualTo(new Object[]{readValue("{\"a\":1}"), readValue("{\"b\":2}")});
+        assertThatJson("{\"test\":[{\"a\":1}, {\"b\":2}]}")
+                .node("test")
+                .isEqualTo(new Object[] {readValue("{\"a\":1}"), readValue("{\"b\":2}")});
     }
 
     @Test
     void isArrayShouldFailIfArrayDoesNotExist() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test2").isArray())
-            .hasMessage("Different value found in node \"test2\", expected: <array> but was: <missing>.");
+                .hasMessage("Different value found in node \"test2\", expected: <array> but was: <missing>.");
     }
 
     @Test
     void isArrayShouldFailIfItIsNotArray() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":\"1\"}").node("test").isArray())
-            .hasMessage("Node \"test\" has invalid type, expected: <array> but was: <\"1\">.");
+                .hasMessage("Node \"test\" has invalid type, expected: <array> but was: <\"1\">.");
     }
 
     @Test
     void arrayOfLengthShouldFailOnIncorrectSize() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").isArray().hasSize(2))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}")
+                        .node("test")
+                        .isArray()
+                        .hasSize(2))
+                .hasMessage(
+                        """
                 [Node "test"]\s
                 Expected size: 2 but was: 3 in:
                 [1, 2, 3]""");
@@ -1312,8 +1471,10 @@ void arrayOfLengthShouldFailOnIncorrectSize() {
 
     @Test
     void shouldReportExtraArrayItemsWhenNotIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo("[1]"))
-            .hasMessage("""
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo("[1]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <1> but was: <3>.
                 Array "test" has different content. Extra values: [2, 3], expected: <[1]> but was: <[1,2,3]>
@@ -1322,8 +1483,12 @@ void shouldReportExtraArrayItemsWhenNotIgnoringOrder() {
 
     @Test
     void shouldReportExtraArrayItemsWhenIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").when(IGNORING_ARRAY_ORDER).node("test").isEqualTo("[1]"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}")
+                        .when(IGNORING_ARRAY_ORDER)
+                        .node("test")
+                        .isEqualTo("[1]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <1> but was: <3>.
                 Array "test" has different content. Missing values: [], extra values: [2, 3], expected: <[1]> but was: <[1,2,3]>
@@ -1333,7 +1498,8 @@ void shouldReportExtraArrayItemsWhenIgnoringOrder() {
     @Test
     void shouldReportMissingArrayItemsWhenNotIgnoringOrder() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":[1]}").node("test").isEqualTo("[1, 2, 3]"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <3> but was: <1>.
                 Array "test" has different content. Missing values: [2, 3], expected: <[1,2,3]> but was: <[1]>
@@ -1342,8 +1508,12 @@ void shouldReportMissingArrayItemsWhenNotIgnoringOrder() {
 
     @Test
     void shouldReportMissingArrayItemsWhenIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1]}").when(IGNORING_ARRAY_ORDER).node("test").isEqualTo("[1, 2, 3]"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[1]}")
+                        .when(IGNORING_ARRAY_ORDER)
+                        .node("test")
+                        .isEqualTo("[1, 2, 3]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <3> but was: <1>.
                 Array "test" has different content. Missing values: [2, 3], extra values: [], expected: <[1,2,3]> but was: <[1]>
@@ -1352,8 +1522,11 @@ void shouldReportMissingArrayItemsWhenIgnoringOrder() {
 
     @Test
     void shouldReportExtraArrayItemsAndDifferencesWhenNotIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[\"x\",\"b\",\"c\"]}").node("test").isEqualTo("[\"a\"]"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[\"x\",\"b\",\"c\"]}")
+                        .node("test")
+                        .isEqualTo("[\"a\"]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <1> but was: <3>.
                 Array "test" has different content. Extra values: ["b", "c"], expected: <["a"]> but was: <["x","b","c"]>
@@ -1368,8 +1541,11 @@ void negativeArrayIndexShouldCountBackwards() {
 
     @Test
     void negativeArrayIndexShouldCountBackwardsAndReportFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[-3]").isEqualTo(3))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                        .node("root.test[-3]")
+                        .isEqualTo(3))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "root.test[-3]", expected: <3> but was: <1>.
                 """);
@@ -1377,8 +1553,11 @@ void negativeArrayIndexShouldCountBackwardsAndReportFailure() {
 
     @Test
     void negativeArrayIndexOutOfBounds() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[-5]").isEqualTo(3))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                        .node("root.test[-5]")
+                        .isEqualTo(3))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Missing node in path "root.test[-5]".
                 """);
@@ -1386,8 +1565,11 @@ void negativeArrayIndexOutOfBounds() {
 
     @Test
     void positiveArrayIndexOutOfBounds() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[5]").isEqualTo(3))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                        .node("root.test[5]")
+                        .isEqualTo(3))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Missing node in path "root.test[5]".
                 """);
@@ -1395,8 +1577,12 @@ void positiveArrayIndexOutOfBounds() {
 
     @Test
     void arrayThatContainsShouldFailOnMissingNode() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[{\"id\":36},{\"id\":37},{\"id\":38}]}").node("test").isArray().contains("{\"id\":42}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[{\"id\":36},{\"id\":37},{\"id\":38}]}")
+                        .node("test")
+                        .isArray()
+                        .contains("{\"id\":42}"))
+                .hasMessage(
+                        """
                 [Node "test"]\s
                 Expecting JsonList:
                   [{"id":36}, {"id":37}, {"id":38}]
@@ -1409,7 +1595,10 @@ but could not find the following element(s):
 
     @Test
     void testContains() {
-        assertThatJson("[\"foo\", \"bar\", null, false, 1]").isArray().hasSize(5).contains("foo", "bar", null, false, valueOf(1));
+        assertThatJson("[\"foo\", \"bar\", null, false, 1]")
+                .isArray()
+                .hasSize(5)
+                .contains("foo", "bar", null, false, valueOf(1));
     }
 
     @Test
@@ -1419,13 +1608,15 @@ void arrayContainsShouldMatch() {
 
     @Test
     void shouldNotParseValueTwice() {
-        assertThatJson("{\"json\": \"{\\\"a\\\" : 1}\"}").node("json").isString().isEqualTo("{\"a\" : 1}");
+        assertThatJson("{\"json\": \"{\\\"a\\\" : 1}\"}")
+                .node("json")
+                .isString()
+                .isEqualTo("{\"a\" : 1}");
     }
 
     @Test
     void regexExample() {
-        assertThatJson("{\"test\": \"ABCD\"}")
-            .isEqualTo("{\"test\": \"${json-unit.regex}[A-Z]+\"}");
+        assertThatJson("{\"test\": \"ABCD\"}").isEqualTo("{\"test\": \"${json-unit.regex}[A-Z]+\"}");
     }
 
     @Test
@@ -1434,37 +1625,38 @@ void pathEscapingWorks() {
         final String pomPath = "C:\\path\\file.ext";
 
         System.out.println(json);
-        assertThatJson(json)
-            .isObject()
-            .containsKey(pomPath);
+        assertThatJson(json).isObject().containsKey(pomPath);
 
         assertThatJson(json)
-            .node(pomPath.replace(".", "\\."))
-            .isPresent()
-            .isObject()
-            .contains(entry("Status", "OK"));
+                .node(pomPath.replace(".", "\\."))
+                .isPresent()
+                .isObject()
+                .contains(entry("Status", "OK"));
     }
 
-
     @Test
     void testArrayShouldMatchRegardlessOfOrder() {
 
-        final String actual = "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"}],\"id\":123}]}";
-        final String expected = "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"}],\"id\":123}]}";
+        final String actual =
+                "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"}],\"id\":123}]}";
+        final String expected =
+                "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"}],\"id\":123}]}";
 
         assertThatJson(actual).when(Option.IGNORING_ARRAY_ORDER).isEqualTo(expected);
     }
 
-
     @Test
     void objectShouldMatch() {
-        assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}").node("test").isArray().allSatisfy(v -> assertThatJson(v).node("value").isNumber().isLessThan(valueOf(4)));
+        assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
+                .node("test")
+                .isArray()
+                .allSatisfy(v -> assertThatJson(v).node("value").isNumber().isLessThan(valueOf(4)));
     }
 
     @Test
     void isStringShouldFailIfItIsNotAString() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").isString())
-            .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <1>.");
+                .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <1>.");
     }
 
     @Test
@@ -1480,28 +1672,31 @@ void testIssue3SpaceStrings() {
     @Test
     void testTreatNullAsAbsent() {
         assertThatJson("{\"test\":{\"a\":1, \"b\": null}}")
-            .when(TREATING_NULL_AS_ABSENT)
-            .isEqualTo("{\"test\":{\"a\":1}}");
+                .when(TREATING_NULL_AS_ABSENT)
+                .isEqualTo("{\"test\":{\"a\":1}}");
     }
 
     @Test
     void shouldIgnoreExtraFields() {
-        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}").when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
+        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
+                .when(IGNORING_EXTRA_FIELDS)
+                .isEqualTo("{\"test\":{\"b\":2}}");
     }
 
     @Test
     void shouldIgnoreExtraFieldsAndOrderExample() {
         assertThatJson("{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}")
-            .when(IGNORING_EXTRA_FIELDS, IGNORING_ARRAY_ORDER)
-            .isEqualTo("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}");
+                .when(IGNORING_EXTRA_FIELDS, IGNORING_ARRAY_ORDER)
+                .isEqualTo("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}");
     }
 
     @Test
     void andFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}").and(
-            a -> a.node("test").isObject(),
-            a -> a.node("test.b").isEqualTo(3)
-        )).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
+                        .and(a -> a.node("test").isObject(), a -> a.node("test.b")
+                                .isEqualTo(3)))
+                .hasMessage(
+                        """
             JSON documents are different:
             Different value found in node "test.b", expected: <3> but was: <2>.
             """);
@@ -1509,18 +1704,17 @@ void andFailure() {
 
     @Test
     void andSuccess() {
-        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}").and(
-            a -> a.node("test").isObject(),
-            a -> a.node("test.b").isEqualTo(2)
-        );
+        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
+                .and(a -> a.node("test").isObject(), a -> a.node("test.b").isEqualTo(2));
     }
 
     @Test
     void andNestedFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}").node("test").and(
-            a -> a.node("a").isEqualTo(1),
-            a -> a.node("b").isEqualTo(3)
-        )).hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
+                        .node("test")
+                        .and(a -> a.node("a").isEqualTo(1), a -> a.node("b").isEqualTo(3)))
+                .hasMessage(
+                        """
             JSON documents are different:
             Different value found in node "test.b", expected: <3> but was: <2>.
             """);
@@ -1528,10 +1722,9 @@ void andNestedFailure() {
 
     @Test
     void andNestedSuccess() {
-        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}").node("test").and(
-            a -> a.node("a").isEqualTo(1),
-            a -> a.node("b").isEqualTo(2)
-        );
+        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
+                .node("test")
+                .and(a -> a.node("a").isEqualTo(1), a -> a.node("b").isEqualTo(2));
     }
 
     @Test
@@ -1546,8 +1739,11 @@ void shouldAcceptEscapedPathWithTwoDots() {
 
     @Test
     void shouldAcceptEscapedPathAndShowCorrectErrorMessage() {
-        assertThatThrownBy(() -> assertThatJson("{\"foo.bar\":\"boo\"}").node("foo\\.bar").isEqualTo("baz"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"foo.bar\":\"boo\"}")
+                        .node("foo\\.bar")
+                        .isEqualTo("baz"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "foo\\.bar", expected: <"baz"> but was: <"boo">.
                 """);
@@ -1555,9 +1751,7 @@ void shouldAcceptEscapedPathAndShowCorrectErrorMessage() {
 
     @Test
     void testCompareArrays() {
-        assertThatJson("[{\"b\": 10}]")
-            .isArray()
-            .isEqualTo(json("[{\"b\": 10}]"));
+        assertThatJson("[{\"b\": 10}]").isArray().isEqualTo(json("[{\"b\": 10}]"));
     }
 
     @Test
@@ -1569,7 +1763,8 @@ void asStringShouldWork() {
     @Test
     void shouldWorkWithPercentSign() {
         assertThatThrownBy(() -> assertThatJson("{\"a\": \"1\"}").isEqualTo("{\"%\": \"2\"}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "%", extra: "a", expected: <{"%":"2"}> but was: <{"a":"1"}>
                 """);
@@ -1578,17 +1773,13 @@ void shouldWorkWithPercentSign() {
     @Test
     void shouldIgnoreFields() {
         assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}")
-            .isObject()
-            .isEqualToIgnoringGivenFields("{\"root\":{\"test\":1, \"ignored\": 2}}", "root.ignored");
-
+                .isObject()
+                .isEqualToIgnoringGivenFields("{\"root\":{\"test\":1, \"ignored\": 2}}", "root.ignored");
     }
 
     @Test
     void arrayWithStringBooleansShouldBeComparable() {
-        assertThatJson("{\"array\": [\"true\"]}")
-            .node("array")
-            .isArray()
-            .containsExactly(value("true"));
+        assertThatJson("{\"array\": [\"true\"]}").node("array").isArray().containsExactly(value("true"));
     }
 
     // *****************************************************************************************************************
@@ -1596,20 +1787,21 @@ void arrayWithStringBooleansShouldBeComparable() {
     // *****************************************************************************************************************
     @Test
     void jsonPathShouldBeAbleToUseObjects() {
-        assertThatThrownBy(() -> assertThatJson(json)
-            .describedAs("My little assert")
-            .inPath("$.store.book[0]")
-            .isEqualTo(
-                """
+        assertThatThrownBy(
+                        () -> assertThatJson(json)
+                                .describedAs("My little assert")
+                                .inPath("$.store.book[0]")
+                                .isEqualTo(
+                                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 8.96
                                 }\
-                    """
-            ))
-            .hasMessage("""
+                    """))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "$.store.book[0].price", expected: <8.96> but was: <8.95>.
                 """);
@@ -1618,139 +1810,129 @@ void jsonPathShouldBeAbleToUseObjects() {
     @Test
     void jsonPathWithIgnoredPaths() {
         assertThatJson(json)
-            .withConfiguration(c -> c.whenIgnoringPaths("$.store.book[*].price"))
-            .inPath("$.store.book[0]")
-            .isEqualTo(
-                """
+                .withConfiguration(c -> c.whenIgnoringPaths("$.store.book[*].price"))
+                .inPath("$.store.book[0]")
+                .isEqualTo(
+                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 999
                                 }\
-                    """
-            );
+                    """);
     }
 
     @Test
     void ignoredJsonPaths() {
-        assertThatJson("""
+        assertThatJson(
+                        """
             {
                  "category": "reference",
                  "author": "Nigel Rees",
                  "title": "Sayings of the Century",
                  "price": 1111
             }""")
-            .withConfiguration(c -> c.whenIgnoringPaths("$..price"))
-            .isEqualTo(
-                """
+                .withConfiguration(c -> c.whenIgnoringPaths("$..price"))
+                .isEqualTo(
+                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 999
                                 }\
-                    """
-            );
+                    """);
     }
 
     @Test
     public void ignoredJsonPathComplex() {
-        assertThatJson("{\"fields\":[" +
-                "{\"key\":1, \"name\":\"AA\"}," +
-                "{\"key\":2, \"name\":\"AB\"}," +
-                "{\"key\":3, \"name\":\"AC\"}" +
-            "]}")
-            .whenIgnoringPaths("$.fields[?(@.name=='AA')].key")
-            .isEqualTo("{\"fields\":[" +
-                "{\"key\":2, \"name\":\"AA\"}," +
-                "{\"key\":2, \"name\":\"AB\"}," +
-                "{\"key\":3, \"name\":\"AC\"}" +
-            "]}");
+        assertThatJson("{\"fields\":[" + "{\"key\":1, \"name\":\"AA\"},"
+                        + "{\"key\":2, \"name\":\"AB\"},"
+                        + "{\"key\":3, \"name\":\"AC\"}"
+                        + "]}")
+                .whenIgnoringPaths("$.fields[?(@.name=='AA')].key")
+                .isEqualTo("{\"fields\":[" + "{\"key\":2, \"name\":\"AA\"},"
+                        + "{\"key\":2, \"name\":\"AB\"},"
+                        + "{\"key\":3, \"name\":\"AC\"}"
+                        + "]}");
     }
 
     @Test
     void jsonPathWithIgnoredNonexistentPaths() {
         assertThatJson(json)
-            .withConfiguration(c -> c.whenIgnoringPaths("$.rubbish"))
-            .inPath("$.store.book[0]")
-            .isEqualTo(
-                """
+                .withConfiguration(c -> c.whenIgnoringPaths("$.rubbish"))
+                .inPath("$.store.book[0]")
+                .isEqualTo(
+                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 8.95
                                 }\
-                    """
-            );
+                    """);
     }
 
     @Test
     void jsonPathWithIgnoredPathsDeep() {
         assertThatJson(json)
-            .whenIgnoringPaths("$..price")
-            .withTolerance(0.01)
-            .inPath("$.store.book[0]")
-            .isEqualTo(
-                """
+                .whenIgnoringPaths("$..price")
+                .withTolerance(0.01)
+                .inPath("$.store.book[0]")
+                .isEqualTo(
+                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 999
                                 }\
-                    """
-            );
+                    """);
     }
 
     @Test
     void jsonPathWithIgnoredPathsDeepBracketNotation() {
         assertThatJson(json)
-            .whenIgnoringPaths("$..price")
-            .inPath("$['store']['book'][0]")
-            .isEqualTo(
-                """
+                .whenIgnoringPaths("$..price")
+                .inPath("$['store']['book'][0]")
+                .isEqualTo(
+                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 999
                                 }\
-                    """
-            );
+                    """);
     }
 
     @Test
     void jsonPathWithNode() {
-        assertThatJson(json)
-            .inPath("$.store.book[0]")
-            .node("title")
-            .isEqualTo("Sayings of the Century");
+        assertThatJson(json).inPath("$.store.book[0]").node("title").isEqualTo("Sayings of the Century");
     }
 
     @Test
     void jsonPathWithNodeError() {
         assertThatThrownBy(() -> assertThatJson(json)
-            .inPath("$.store.book[0]")
-            .node("title")
-            .isEqualTo("Sayings of the Century2")
-        ).hasMessage("JSON documents are different:\nDifferent value found in node \"$.store.book[0].title\", expected: <\"Sayings of the Century2\"> but was: <\"Sayings of the Century\">.\n");
+                        .inPath("$.store.book[0]")
+                        .node("title")
+                        .isEqualTo("Sayings of the Century2"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"$.store.book[0].title\", expected: <\"Sayings of the Century2\"> but was: <\"Sayings of the Century\">.\n");
     }
 
     @Test
     void jsonPathNumber() {
-        assertThatJson(json)
-            .inPath("$..book.length()")
-            .isEqualTo(valueOf(4));
+        assertThatJson(json).inPath("$..book.length()").isEqualTo(valueOf(4));
     }
 
     @Test
     void booleanArrayExtractionShouldWork() {
         assertThatJson("{\"fields\": [{ \"id\": \"test\", \"value\": \"true\" }]}")
-            .inPath("$.fields[?(@.id==\"test\")].value")
-            .isArray()
-            .containsExactly(value("true"));
+                .inPath("$.fields[?(@.id==\"test\")].value")
+                .isArray()
+                .containsExactly(value("true"));
     }
 
     @Test
@@ -1759,9 +1941,9 @@ void stringComparisonShouldWork() {
         map.put("FOO", 4);
         map.put("BAR", 3);
         assertThatJson("{\"fields\": [{ \"id\": \"test\", \"value\": \"{FOO=4, BAR=3}\" }]}")
-            .inPath("$.fields[?(@.id==\"test\")].value")
-            .isArray()
-            .containsExactly(value(map.toString()));
+                .inPath("$.fields[?(@.id==\"test\")].value")
+                .isArray()
+                .containsExactly(value(map.toString()));
     }
 
     @Test
@@ -1772,7 +1954,8 @@ void testAbsentInJsonPath() {
     @Test
     void testAbsentInJsonPathEquals() {
         assertThatThrownBy(() -> assertThatJson("{}").inPath("$.abc").isEqualTo("value"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Missing node in path "$.abc".
                 """);
@@ -1781,31 +1964,33 @@ void testAbsentInJsonPathEquals() {
     @Test
     void testAbsentInJsonPathIsArray() {
         assertThatThrownBy(() -> assertThatJson("{}").inPath("$.abc").isArray())
-            .hasMessage("Different value found in node \"$.abc\", expected: <array> but was: <missing>.");
+                .hasMessage("Different value found in node \"$.abc\", expected: <array> but was: <missing>.");
     }
 
     @Test
     void testAbsentInJsonPathNotAbsent() {
         assertThatThrownBy(() -> assertThatJson("{\"abc\": 1}").inPath("$.abc").isAbsent())
-            .hasMessage("Different value found in node \"$.abc\", expected: <node to be absent> but was: <1>.");
+                .hasMessage("Different value found in node \"$.abc\", expected: <node to be absent> but was: <1>.");
     }
 
     @Test
     protected void jsonPathShouldBeAbleToUseArrays() {
-        assertThatThrownBy(() -> assertThatJson(json)
-            .inPath("$.store.book")
-            .isArray()
-            .contains(json(
-                """
+        assertThatThrownBy(
+                        () -> assertThatJson(json)
+                                .inPath("$.store.book")
+                                .isArray()
+                                .contains(
+                                        json(
+                                                """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
                                     "title": "Sayings of the Century",
                                     "price": 8.96
                                 }\
-                    """
-            )))
-            .hasMessage("""
+                    """)))
+                .hasMessage(
+                        """
                 [Node "$.store.book"]\s
                 Expecting JsonList:
                   [{"author":"Nigel Rees","category":"reference","price":8.95,"title":"Sayings of the Century"},
@@ -1822,61 +2007,63 @@ but could not find the following element(s):
     @Test
     void jsonPathShouldBeAbleToUseArraysDeep() {
         assertThatJson(json)
-            .inPath("$.store.book[*].category")
-            .isArray()
-            .containsExactlyInAnyOrder("fiction", "reference", "fiction", "fiction");
+                .inPath("$.store.book[*].category")
+                .isArray()
+                .containsExactlyInAnyOrder("fiction", "reference", "fiction", "fiction");
     }
 
     @Test
     void jsonPathShouldBeAbleToUseArraysFromObject() {
         assertThatJson(readValue(json))
-            .inPath("$.store.book[*].category")
-            .isArray()
-            .containsExactlyInAnyOrder("fiction", "reference", "fiction", "fiction");
+                .inPath("$.store.book[*].category")
+                .isArray()
+                .containsExactlyInAnyOrder("fiction", "reference", "fiction", "fiction");
     }
 
     @Test
     void ignoreExtraArrayItemsExample() {
-        assertThatJson("{\"test\":[1,2,3,4]}")
-            .when(IGNORING_EXTRA_ARRAY_ITEMS)
-            .isEqualTo("{\"test\":[1,2,3]}");
+        assertThatJson("{\"test\":[1,2,3,4]}").when(IGNORING_EXTRA_ARRAY_ITEMS).isEqualTo("{\"test\":[1,2,3]}");
     }
 
     @Test
     void ignoreExtraArrayItemsAndOrderExample() {
         assertThatJson("{\"test\":[5,5,4,4,3,3,2,2,1,1]}")
-            .when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)
-            .isEqualTo("{\"test\":[1,2,3]}");
+                .when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)
+                .isEqualTo("{\"test\":[1,2,3]}");
     }
 
     @Test
     void testArrayBug() {
-        assertThatJson("""
+        assertThatJson(
+                        """
             [
                   {"value": "1", "title": "Entity", "info": "Entity info"},
                   {"value": "2", "title": "Column", "info": "Column info"},
                   {"value": "3", "title": "Table", "info": "Table info"},
                   {"value": "4", "title": "Schema", "info": "Schema info"}
                 ]""")
-            .inPath("$[?(@.value =='1')]")
-            .isArray().last()
-            .isEqualTo(json("{\"value\": \"1\", \"title\": \"Entity\", \"info\": \"Entity info\"}"));
+                .inPath("$[?(@.value =='1')]")
+                .isArray()
+                .last()
+                .isEqualTo(json("{\"value\": \"1\", \"title\": \"Entity\", \"info\": \"Entity info\"}"));
     }
 
     @Test
     void testArrayNode() {
-        assertThatJson("""
+        assertThatJson(
+                        """
             [
                   {"value": "1", "title": "Entity", "info": "Entity info"},
                   {"value": "2", "title": "Column", "info": "Column info"},
                   {"value": "3", "title": "Table", "info": "Table info"},
                   {"value": "4", "title": "Schema", "info": "Schema info"}
                 ]""")
-            .inPath("$[?(@.value =='1')]")
-            .isArray().first()
-            .node("title")
-            .isString()
-            .isEqualTo("Entity");
+                .inPath("$[?(@.value =='1')]")
+                .isArray()
+                .first()
+                .node("title")
+                .isString()
+                .isEqualTo("Entity");
     }
 
     @Test
@@ -1887,13 +2074,13 @@ void assertSame() {
 
     @Test
     void testArrayElements() {
-        String json = "[ [ \"a\", \"b\", \"c\", \"d\","
-            + " \"e\", \"f\", \"g\", \"h\", \"i\" ] ]";
+        String json = "[ [ \"a\", \"b\", \"c\", \"d\"," + " \"e\", \"f\", \"g\", \"h\", \"i\" ] ]";
 
-        assertThatJson(json).inPath("$.[0]")
-            .isArray()
-            .elements(3 /* d */, 4 /* e */, 5 /* f */ , 6 /* g */, 7 /* h */, 8 /* i */ )
-            .containsExactly("d", "e", "f", "g", "h", "i");
+        assertThatJson(json)
+                .inPath("$.[0]")
+                .isArray()
+                .elements(3 /* d */, 4 /* e */, 5 /* f */, 6 /* g */, 7 /* h */, 8 /* i */)
+                .containsExactly("d", "e", "f", "g", "h", "i");
     }
 
     @Test
@@ -1924,46 +2111,48 @@ void shouldUseInPathInAnd() {
     @Test
     void shouldIgnoreArrayOrderInSpecificPath() {
         assertThatJson("{\"obj\":{\"a\": [1, 2], \"b\": [3, 4]}}")
-            .when(path("obj.a"), then(IGNORING_ARRAY_ORDER))
-            .isEqualTo("{\"obj\":{\"a\": [2, 1], \"b\": [3, 4]}}");
+                .when(path("obj.a"), then(IGNORING_ARRAY_ORDER))
+                .isEqualTo("{\"obj\":{\"a\": [2, 1], \"b\": [3, 4]}}");
     }
 
     @Test
     void shouldNotIgnoreArrayOrderWhenNotSpecified() {
         assertThatJson("{\"obj\":{\"a\": [1, 2], \"b\": [3, 4]}}")
-            .when(path("obj.a"), then(IGNORING_ARRAY_ORDER))
-            .isNotEqualTo("{\"obj\":{\"a\": [2, 1], \"b\": [4, 3]}}");
+                .when(path("obj.a"), then(IGNORING_ARRAY_ORDER))
+                .isNotEqualTo("{\"obj\":{\"a\": [2, 1], \"b\": [4, 3]}}");
     }
 
     @Test
     void shouldExcludeIgnoringArrayOrderFromPath() {
         assertThatJson("[{\"b\":[4,5,6]},{\"b\":[1,2,3]}]")
-            .when(IGNORING_ARRAY_ORDER)
-            .when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER))
-            .isEqualTo("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]");
+                .when(IGNORING_ARRAY_ORDER)
+                .when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER))
+                .isEqualTo("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]");
     }
 
     @Test
     void shouldIgnoreArrayOrderInSpecificJsonPath() {
         assertThatJson("{\"obj\":{\"a\": [1, 2], \"b\": [3, 4]}}")
-            .when(path("$..a"), then(IGNORING_ARRAY_ORDER))
-            .isEqualTo("{\"obj\":{\"a\": [2, 1], \"b\": [3, 4]}}");
+                .when(path("$..a"), then(IGNORING_ARRAY_ORDER))
+                .isEqualTo("{\"obj\":{\"a\": [2, 1], \"b\": [3, 4]}}");
     }
 
     @Test
     void shouldExcludeIgnoringArrayOrderFromPathAndIgnoreInRoot() {
         assertThatJson("[{\"b\":[4,5,6]},{\"b\":[1,2,3]},{\"b\":[7,8,9]}]")
-            .when(rootPath(), then(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS))
-            .when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER))
-            .isEqualTo("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]");
+                .when(rootPath(), then(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS))
+                .when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER))
+                .isEqualTo("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]");
     }
 
     @Test
     void shouldIgnoreArrayOrderEverywhereButTheFirstElement() {
         assertThatThrownBy(() -> assertThatJson("[{\"b\":[1,3,2]},{\"b\":[5,4,6]},{\"b\":[8,7,9]}]")
-            .when(path("[*].b"), then(IGNORING_ARRAY_ORDER)).when(path("[0].b"), thenNot(IGNORING_ARRAY_ORDER))
-            .isEqualTo("[{\"b\":[1,2,3]},{\"b\":[4,5,6]},{\"b\":[7,8,9]}]"))
-            .hasMessage("""
+                        .when(path("[*].b"), then(IGNORING_ARRAY_ORDER))
+                        .when(path("[0].b"), thenNot(IGNORING_ARRAY_ORDER))
+                        .isEqualTo("[{\"b\":[1,2,3]},{\"b\":[4,5,6]},{\"b\":[7,8,9]}]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "[0].b[1]", expected: <2> but was: <3>.
                 Different value found in node "[0].b[2]", expected: <3> but was: <2>.
@@ -1973,24 +2162,24 @@ void shouldIgnoreArrayOrderEverywhereButTheFirstElement() {
     @Test
     void shouldIgnoreArrayOrderInSeveralSpecificPaths() {
         assertThatJson("[{\"b\":[3,1,2],\"c\":[-2,-3,-1]},{\"b\":[6,5,4],\"c\":[-5,-4,-6]}]")
-            .when(paths("[*].b", "[*].c"), then(IGNORING_ARRAY_ORDER))
-            .isEqualTo("[{\"b\":[1,2,3],\"c\":[-1,-2,-3]},{\"b\":[4,5,6],\"c\":[-4,-5,-6]}]");
+                .when(paths("[*].b", "[*].c"), then(IGNORING_ARRAY_ORDER))
+                .isEqualTo("[{\"b\":[1,2,3],\"c\":[-1,-2,-3]},{\"b\":[4,5,6],\"c\":[-4,-5,-6]}]");
     }
 
     @Test
     void shouldTreatNullAsAbsentInSpecificPath() {
         assertThatJson("{\"a\":1,\"b\":null}")
-            .when(path("b"), then(TREATING_NULL_AS_ABSENT))
-            .isEqualTo("{\"a\":1}");
+                .when(path("b"), then(TREATING_NULL_AS_ABSENT))
+                .isEqualTo("{\"a\":1}");
     }
 
     @Test
     void shouldNotTreatNullAsAbsentWhenNotSpecified() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"a\":1,\"b\":null,\"c\":null}")
-                .when(path("b"), then(TREATING_NULL_AS_ABSENT))
-                .isEqualTo("{\"a\":1}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":1,\"b\":null,\"c\":null}")
+                        .when(path("b"), then(TREATING_NULL_AS_ABSENT))
+                        .isEqualTo("{\"a\":1}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", extra: "c", expected: <{"a":1}> but was: <{"a":1,"b":null,"c":null}>
                 """);
@@ -1999,17 +2188,17 @@ void shouldNotTreatNullAsAbsentWhenNotSpecified() {
     @Test
     void shouldIgnoreExtraFieldsInSpecificPath() {
         assertThatJson("{\"a\":{\"a1\":1,\"a2\":2}}")
-            .when(path("a"), then(IGNORING_EXTRA_FIELDS))
-            .isEqualTo("{\"a\":{\"a1\":1}}");
+                .when(path("a"), then(IGNORING_EXTRA_FIELDS))
+                .isEqualTo("{\"a\":{\"a1\":1}}");
     }
 
     @Test
     void shouldNotIgnoreExtraFieldsWhenNotSpecified() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"a\":{\"a1\":1,\"a2\":2},\"b\":{\"b1\":1,\"b2\":2}}")
-                .when(path("a"), then(IGNORING_EXTRA_FIELDS))
-                .isEqualTo("{\"a\":{\"a1\":1},\"b\":{\"b1\":1}}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":{\"a1\":1,\"a2\":2},\"b\":{\"b1\":1,\"b2\":2}}")
+                        .when(path("a"), then(IGNORING_EXTRA_FIELDS))
+                        .isEqualTo("{\"a\":{\"a1\":1},\"b\":{\"b1\":1}}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "b", extra: "b.b2", expected: <{"b1":1}> but was: <{"b1":1,"b2":2}>
                 """);
@@ -2018,17 +2207,17 @@ void shouldNotIgnoreExtraFieldsWhenNotSpecified() {
     @Test
     void shouldIgnoreExtraArrayItemsInSpecificPath() {
         assertThatJson("{\"a\":[1,2,3]}")
-            .when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS))
-            .isEqualTo("{\"a\":[1,2]}");
+                .when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS))
+                .isEqualTo("{\"a\":[1,2]}");
     }
 
     @Test
     void shouldNotIgnoreExtraArrayItemsWhenNotSpecified() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"a\":[1,2,3],\"b\":[1,2,3]}")
-                .when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS))
-                .isEqualTo("{\"a\":[1,2],\"b\":[1,2]}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":[1,2,3],\"b\":[1,2,3]}")
+                        .when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS))
+                        .isEqualTo("{\"a\":[1,2],\"b\":[1,2]}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "b" has different length, expected: <2> but was: <3>.
                 Array "b" has different content. Extra values: [3], expected: <[1,2]> but was: <[1,2,3]>
@@ -2038,32 +2227,32 @@ void shouldNotIgnoreExtraArrayItemsWhenNotSpecified() {
     @Test
     void shouldIgnoreValuesInSpecificPath() {
         assertThatJson("{\"a\":2,\"b\":\"string2\"}")
-            .when(paths("a", "b"), then(IGNORING_VALUES))
-            .isEqualTo("{\"a\":1,\"b\":\"string\"}");
+                .when(paths("a", "b"), then(IGNORING_VALUES))
+                .isEqualTo("{\"a\":1,\"b\":\"string\"}");
     }
 
     @Test
     void shouldIgnoreValuesInSpecificPathWrittenSeparately() {
         assertThatJson("{\"a\":2,\"b\":\"string2\"}")
-            .when(path("a"), then(IGNORING_VALUES))
-            .when(path("b"), then(IGNORING_VALUES))
-            .isEqualTo("{\"a\":1,\"b\":\"string\"}");
+                .when(path("a"), then(IGNORING_VALUES))
+                .when(path("b"), then(IGNORING_VALUES))
+                .isEqualTo("{\"a\":1,\"b\":\"string\"}");
     }
 
     @Test
     void shouldIgnoreAbsentB() {
         assertThatJson("{\"A\":1,\"B\":null}")
-            .when(path("B"), then(TREATING_NULL_AS_ABSENT))
-            .isEqualTo("{\"A\":1}");
+                .when(path("B"), then(TREATING_NULL_AS_ABSENT))
+                .isEqualTo("{\"A\":1}");
     }
 
     @Test
     void shouldNotIgnoreValuesWhenNotSpecified() {
-        assertThatThrownBy(() ->
-            assertThatJson("{\"a\":2,\"b\":\"string2\",\"c\":3}")
-                .when(paths("a", "b"), then(IGNORING_VALUES))
-                .isEqualTo("{\"a\":1,\"b\":\"string\",\"c\":2}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"a\":2,\"b\":\"string2\",\"c\":3}")
+                        .when(paths("a", "b"), then(IGNORING_VALUES))
+                        .isEqualTo("{\"a\":1,\"b\":\"string\",\"c\":2}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "c", expected: <2> but was: <3>.
                 """);
@@ -2072,19 +2261,20 @@ void shouldNotIgnoreValuesWhenNotSpecified() {
     @Test
     void shouldIgnoreMultiplePaths() {
         assertThatJson("{\"a\":1,\"b\":2,\"c\":3}")
-            .when(paths("a", "b"), thenIgnore())
-            .isEqualTo("{\"c\":3}");
+                .when(paths("a", "b"), thenIgnore())
+                .isEqualTo("{\"c\":3}");
     }
 
     @Test
     void shouldIgnoreMultiplePathsWrittenSeparately() {
         assertThatJson("{\"a\":1,\"b\":2,\"c\":3}")
-            .when(path("a"), thenIgnore())
-            .when(path("b"), thenIgnore())
-            .isEqualTo("{\"c\":3}");
+                .when(path("a"), thenIgnore())
+                .when(path("b"), thenIgnore())
+                .isEqualTo("{\"c\":3}");
     }
 
-    private static final String json = """
+    private static final String json =
+            """
         {
             "store": {
                 "book": [
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonAssertTest.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonAssertTest.java
index fe3a3d9bf..4fcf84b61 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonAssertTest.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonAssertTest.java
@@ -15,18 +15,6 @@
  */
 package net.javacrumbs.jsonunit.test.base;
 
-import net.javacrumbs.jsonunit.JsonAssert;
-import net.javacrumbs.jsonunit.core.ParametrizedMatcher;
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Test;
-
-import java.io.StringReader;
-import java.math.BigDecimal;
-import java.nio.charset.StandardCharsets;
-
 import static java.math.BigDecimal.ZERO;
 import static java.math.BigDecimal.valueOf;
 import static java.util.Collections.singletonMap;
@@ -61,6 +49,17 @@
 import static org.hamcrest.Matchers.greaterThan;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.nio.charset.StandardCharsets;
+import net.javacrumbs.jsonunit.JsonAssert;
+import net.javacrumbs.jsonunit.core.ParametrizedMatcher;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
 public abstract class AbstractJsonAssertTest {
 
     @AfterEach
@@ -83,7 +82,8 @@ protected void shouldParseExpectedValueLeniently() {
 
     @Test
     public void shouldFailIfQuotationMarksMissingOnActualKeys() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{test: 1}")).isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{test: 1}"))
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
@@ -94,7 +94,8 @@ void testArray() {
     @Test
     void testArrayDifferent() {
         assertThatThrownBy(() -> assertJsonEquals("[{\"test\":1}, {\"test\":2}]", "[{\n\"test\": 1\n}, {\"test\": 4}]"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"[1].test\", expected: <2> but was: <4>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"[1].test\", expected: <2> but was: <4>.\n");
     }
 
     @Test
@@ -106,13 +107,15 @@ void testSimple() {
     void testNumberAndString() {
         setTolerance(0.001);
         assertThatThrownBy(() -> assertJsonEquals(1, "\"hi\""))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"\", expected: <1> but was: <\"hi\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"\", expected: <1> but was: <\"hi\">.\n");
     }
 
     @Test
     void testSimpleDifferent() {
         assertThatThrownBy(() -> assertJsonEquals("1", "\n2\n"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"\", expected: <1> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"\", expected: <1> but was: <2>.\n");
     }
 
     @Test
@@ -122,13 +125,15 @@ void testSimpleIgnore() {
 
     @Test
     void testInvalidJsonActual() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"foo\": 1\n")).isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"foo\": 1\n"))
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void testObjectName() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"foo\": 1\n}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "test", extra: "foo", expected: <{"test":1}> but was: <{"foo":1}>
                 """);
@@ -147,7 +152,8 @@ void testNulls() {
     @Test
     protected void testNotEqualWhenToleranceNotSet() {
         assertThatThrownBy(() -> assertJsonEquals("1", "\n1.0\n"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "", expected: <1> but was: <1.0>.
                 """);
@@ -174,7 +180,8 @@ void testComparisonWhenWithinToleranceNegative() {
     void testComparisonWhenOverTolerance() {
         setTolerance(0.01);
         assertThatThrownBy(() -> assertJsonEquals("1", "\n1.1\n"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "", expected: <1> but was: <1.1>, difference is 0.1, tolerance is 0.01
                 """);
@@ -184,7 +191,8 @@ void testComparisonWhenOverTolerance() {
     void testComparisonWhenOverZeroTolerance() {
         setTolerance(0);
         assertThatThrownBy(() -> assertJsonEquals("1", "\n1.1\n"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "", expected: <1> but was: <1.1>.
                 """);
@@ -198,13 +206,15 @@ void testNullOk() {
     @Test
     void testNullFail() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":null}", "{\n\"test\": 1\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <null> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <null> but was: <1>.\n");
     }
 
     @Test
     void testExtraRootKey() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n, \"foo\": 2}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", extra: "foo", expected: <{"test":1}> but was: <{"foo":2,"test":1}>
                 """);
@@ -212,8 +222,10 @@ void testExtraRootKey() {
 
     @Test
     void testIgnoreOneElement() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}", "{\n\"test\": 1\n, \"foo\": 2}"))
-            .hasMessage("""
+        assertThatThrownBy(
+                        () -> assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}", "{\n\"test\": 1\n, \"foo\": 2}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", extra: "foo", expected: <{"test":"${json-unit.ignore}"}> but was: <{"foo":2,"test":1}>
                 """);
@@ -222,7 +234,8 @@ void testIgnoreOneElement() {
     @Test
     void testMissingRootKey() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":1, \"foo\": 2}", "{\n\"test\": 1\n}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "foo", expected: <{"foo":2,"test":1}> but was: <{"test":1}>
                 """);
@@ -231,13 +244,15 @@ void testMissingRootKey() {
     @Test
     void testDifferentNumericValue() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"test\": 2\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void testDifferentBooleanValue() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":true}", "{\n\"test\": false\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <true> but was: <false>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <true> but was: <false>.\n");
     }
 
     @Test
@@ -253,7 +268,8 @@ void testIgnoreArray() {
     @Test
     void testDifferentArrayLength() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1, 2, 3]}", "{\n\"test\": [1, 2]\n}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <3> but was: <2>.
                 Array "test" has different content. Missing values: [3], expected: <[1,2,3]> but was: <[1,2]>
@@ -262,8 +278,12 @@ void testDifferentArrayLength() {
 
     @Test
     void testDifferentArrayLengthWhenIgnoringArrayOrder() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[\"a\", \"b\", \"c\"]}", "{\n\"test\": [\"a\", \"b\"]\n}", when(IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[\"a\", \"b\", \"c\"]}",
+                        "{\n\"test\": [\"a\", \"b\"]\n}",
+                        when(IGNORING_ARRAY_ORDER)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <3> but was: <2>.
                 Array "test" has different content. Missing values: ["c"], extra values: [], expected: <["a","b","c"]> but was: <["a","b"]>
@@ -273,25 +293,29 @@ void testDifferentArrayLengthWhenIgnoringArrayOrder() {
     @Test
     void testDifferentArrayValue() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1, 2, 3]}", "{\n\"test\": [1, 2, 5]\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test[2]\", expected: <3> but was: <5>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test[2]\", expected: <3> but was: <5>.\n");
     }
 
     @Test
     void testDifferentArrayType() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1, 2, 3]}", "{\n\"test\": [1, false, 3]\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test[1]\", expected: <2> but was: <false>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test[1]\", expected: <2> but was: <false>.\n");
     }
 
     @Test
     void testComplexOk() {
-        assertJsonEquals("{\"test\":[1, 2, {\"child\":{\"value1\":1, \"value2\":true, \"value3\": \"test\", \"value4\":{\"leaf\":5}}}], \"root2\": false}",
-            "{\"test\":[1, 2, {\"child\":{\"value1\":1, \"value2\":true, \"value3\": \"test\", \"value4\":{\"leaf\":5}}}], \"root2\": false}");
-
+        assertJsonEquals(
+                "{\"test\":[1, 2, {\"child\":{\"value1\":1, \"value2\":true, \"value3\": \"test\", \"value4\":{\"leaf\":5}}}], \"root2\": false}",
+                "{\"test\":[1, 2, {\"child\":{\"value1\":1, \"value2\":true, \"value3\": \"test\", \"value4\":{\"leaf\":5}}}], \"root2\": false}");
     }
 
     @Test
     void testComplexErrors() {
-        assertThatThrownBy(() -> assertJsonEquals("""
+        assertThatThrownBy(
+                        () -> assertJsonEquals(
+                                """
                 {
                    "test":[
                       1,
@@ -310,7 +334,7 @@ void testComplexErrors() {
                    "root2":false,
                    "root3":1
                 }""",
-            """
+                                """
                 {
                    "test":[
                       5,
@@ -330,9 +354,9 @@ void testComplexErrors() {
                       }
                    ],
                    "root4":"bar"
-                }"""
-        ))
-            .hasMessage("""
+                }"""))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "root2","root3", extra: "root4", expected: <{"root2":false,"root3":1,"test":[1, 2, {"child":{"value1":1,"value2":true,"value3":"test","value4":{"leaf":5}}}]}> but was: <{"root4":"bar","test":[5, false, {"child":{"value1":5,"value2":"true","value3":"test","value4":{"leaf2":5}},"child2":{}}]}>
                 Different value found in node "test[0]", expected: <1> but was: <5>.
@@ -342,7 +366,6 @@ void testComplexErrors() {
                 Different value found in node "test[2].child.value2", expected: <true> but was: <"true">.
                 Different keys found in node "test[2].child.value4", missing: "test[2].child.value4.leaf", extra: "test[2].child.value4.leaf2", expected: <{"leaf":5}> but was: <{"leaf2":5}>
                 """);
-
     }
 
     @Test
@@ -359,26 +382,32 @@ void testIgnoreObjectDifferentPlaceholder() {
 
     @Test
     void testIgnoreObjectErrorInSibling() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":{\"object\": \"${json-unit.ignore}\"}, \"sibling\":1}", "{\n\"test\": {\"object\" : {\"another\" : 1}}, \"sibling\" : 2}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"sibling\", expected: <1> but was: <2>.\n");
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":{\"object\": \"${json-unit.ignore}\"}, \"sibling\":1}",
+                        "{\n\"test\": {\"object\" : {\"another\" : 1}}, \"sibling\" : 2}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"sibling\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     protected void testDifferentNumericTypes() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"test\": 1.0\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <1.0>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <1.0>.\n");
     }
 
     @Test
     void testDifferentType() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":1}", "{\n\"test\": \"something\"\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <\"something\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <\"something\">.\n");
     }
 
     @Test
     void testEmpty() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":{}}", "{\n\"test\": \"something\"\n}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <{}> but was: <\"something\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <{}> but was: <\"something\">.\n");
     }
 
     @Test
@@ -419,13 +448,14 @@ void testAssertPartOkString() {
     @Test
     void testAssertPart() {
         assertThatThrownBy(() -> assertJsonPartEquals("2", "{\"test\":{\"value\":1}}", "test.value"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test.value\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test.value\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertJsonNodeAbsent() {
         assertThatThrownBy(() -> assertJsonNodeAbsent("{\"test\":{\"value\":1}}", "test.value"))
-            .hasMessage("Node \"test.value\" is present.");
+                .hasMessage("Node \"test.value\" is present.");
     }
 
     @Test
@@ -436,13 +466,13 @@ void testAssertJsonNodeAbsentOk() {
     @Test
     void testAssertJsonNodePresent() {
         assertThatThrownBy(() -> assertJsonNodePresent("{\"test\":{\"value\":1}}", "test.different"))
-            .hasMessage("Node \"test.different\" is missing.");
+                .hasMessage("Node \"test.different\" is missing.");
     }
 
     @Test
     void testAssertJsonNodePresentInArray() {
         assertThatThrownBy(() -> assertJsonNodePresent("{\"array\":[1, 2]}", "array[3]"))
-            .hasMessage("Node \"array[3]\" is missing.");
+                .hasMessage("Node \"array[3]\" is missing.");
     }
 
     @Test
@@ -453,7 +483,8 @@ void testAssertJsonNodePresentOk() {
     @Test
     void testAssertPartComplex() {
         assertThatThrownBy(() -> assertJsonPartEquals("{\"value\":2}", "{\"test\":{\"value\":1}}", "test"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test.value\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test.value\", expected: <2> but was: <1>.\n");
     }
 
     @Test
@@ -464,19 +495,21 @@ void testAssertPartArrayOk() {
     @Test
     void testAssertPartArray() {
         assertThatThrownBy(() -> assertJsonPartEquals(3, "{\"test\":[{\"value\":1},{\"value\":2}]}", "test[1].value"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test[1].value\", expected: <3> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test[1].value\", expected: <3> but was: <2>.\n");
     }
 
     @Test
     void testAssertPartNonexisting() {
         assertThatThrownBy(() -> assertJsonPartEquals("2", "{\"test\":{\"value\":1}}", "test.bogus"))
-            .hasMessage("JSON documents are different:\nMissing node in path \"test.bogus\".\n");
+                .hasMessage("JSON documents are different:\nMissing node in path \"test.bogus\".\n");
     }
 
     @Test
     void testNullAndAbsent() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":{\"a\":1}}", "{\"test\":{\"a\":1, \"b\": null}}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "test", extra: "test.b", expected: <{"a":1}> but was: <{"a":1,"b":null}>
                 """);
@@ -504,7 +537,8 @@ void testTreatNullAsAbsentTwoValues() {
     void testTreatNullAsNullInExpected() {
         setOptions(TREATING_NULL_AS_ABSENT);
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":{\"a\":1, \"b\": null}}", "{\"test\":{\"a\":1}}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "test", missing: "test.b", expected: <{"a":1,"b":null}> but was: <{"a":1}>
                 """);
@@ -512,8 +546,10 @@ void testTreatNullAsNullInExpected() {
 
     @Test
     void testTreatNullAsNullInExpectedInline() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":{\"a\":1, \"b\": null}}", "{\"test\":{\"a\":1}}", when(TREATING_NULL_AS_ABSENT)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":{\"a\":1, \"b\": null}}", "{\"test\":{\"a\":1}}", when(TREATING_NULL_AS_ABSENT)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "test", missing: "test.b", expected: <{"a":1,"b":null}> but was: <{"a":1}>
                 """);
@@ -528,19 +564,21 @@ void shouldIgnoreArrayOrder() {
     @Test
     void shouldIgnoreArrayOrderOnObjectArrays() {
         JsonAssert.setOptions(IGNORING_ARRAY_ORDER);
-        assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2},{\"key\":1}]}");
+        assertJsonEquals(
+                "{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2},{\"key\":1}]}");
     }
 
     @Test
     void shouldReportOnDifferentValuesWhenIgnoringOrder() {
         try {
             assertJsonEquals(
-                "{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}",
-                "{\"test\":[{\"key\":4},{\"key\":2},{\"key\":1}]}",
-                when(IGNORING_ARRAY_ORDER)
-            );
+                    "{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}",
+                    "{\"test\":[{\"key\":4},{\"key\":2},{\"key\":1}]}",
+                    when(IGNORING_ARRAY_ORDER));
         } catch (AssertionError e) {
-            assertEquals("JSON documents are different:\nDifferent value found when comparing expected array element test[2] to actual element test[0].\nDifferent value found in node \"test[0].key\", expected: <3> but was: <4>.\n", e.getMessage());
+            assertEquals(
+                    "JSON documents are different:\nDifferent value found when comparing expected array element test[2] to actual element test[0].\nDifferent value found in node \"test[0].key\", expected: <3> but was: <4>.\n",
+                    e.getMessage());
         }
     }
 
@@ -548,12 +586,13 @@ void shouldReportOnDifferentValuesWhenIgnoringOrder() {
     void shouldReportOnDifferentValuesWhenIgnoringOrderActualsSame() {
         try {
             assertJsonEquals(
-                "{\"test\":[{\"key\":1},{\"key\":1},{\"key\":2}]}",
-                "{\"test\":[{\"key\":1},{\"key\":1},{\"key\":1}]}",
-                when(IGNORING_ARRAY_ORDER)
-            );
+                    "{\"test\":[{\"key\":1},{\"key\":1},{\"key\":2}]}",
+                    "{\"test\":[{\"key\":1},{\"key\":1},{\"key\":1}]}",
+                    when(IGNORING_ARRAY_ORDER));
         } catch (AssertionError e) {
-            assertEquals("JSON documents are different:\nDifferent value found when comparing expected array element test[2] to actual element test[2].\nDifferent value found in node \"test[2].key\", expected: <2> but was: <1>.\n", e.getMessage());
+            assertEquals(
+                    "JSON documents are different:\nDifferent value found when comparing expected array element test[2] to actual element test[2].\nDifferent value found in node \"test[2].key\", expected: <2> but was: <1>.\n",
+                    e.getMessage());
         }
     }
 
@@ -561,7 +600,8 @@ void shouldReportOnDifferentValuesWhenIgnoringOrderActualsSame() {
     void shouldFailIfArrayContentIsDifferent() {
         setOptions(IGNORING_ARRAY_ORDER);
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,4]}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element test[0] to actual element test[2].
                 Different value found in node "test[2]", expected: <1> but was: <4>.
@@ -575,18 +615,24 @@ void arraysShouldMatchEvenWhenIgnoringExtraFields() {
 
     @Test
     void arraysShouldMatchEvenWhenIgnoringExtraFieldsComplex() {
-        assertJsonEquals("[[3],[2],[1]]", "[[1,2],[2,3],[3,1]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS));
+        assertJsonEquals(
+                "[[3],[2],[1]]", "[[1,2],[2,3],[3,1]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS));
     }
 
     @Test
     void arraysShouldMatchEvenWhenIgnoringExtraFieldsInEmbeddedObjects() {
-        assertJsonEquals("[{\"a\":[\"b\"]},{\"a\":[\"a\"]}]", "[{\"a\":[\"b\",\"a\"]},{\"a\":[\"b\",\"c\"]}]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS));
+        assertJsonEquals(
+                "[{\"a\":[\"b\"]},{\"a\":[\"a\"]}]",
+                "[{\"a\":[\"b\",\"a\"]},{\"a\":[\"b\",\"c\"]}]",
+                when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS));
     }
 
     @Test
     void arraysMatchShouldReportErrorCorrectlyWhenIgnoringExtraFields() {
-        assertThatThrownBy(() -> assertJsonEquals("[[2],[1]]", "[[1,2],[3]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "[[2],[1]]", "[[1,2],[3]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element [1] to actual element [1].
                 Different value found when comparing expected array element [1][0] to actual element [1][0].
@@ -597,7 +643,8 @@ void arraysMatchShouldReportErrorCorrectlyWhenIgnoringExtraFields() {
     @Test
     void exactArrayMatch() {
         assertThatThrownBy(() -> assertJsonEquals("[1,2,3]", "[1,3,2]"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "[1]", expected: <2> but was: <3>.
                 Different value found in node "[2]", expected: <3> but was: <2>.
@@ -606,13 +653,16 @@ void exactArrayMatch() {
 
     @Test
     void arrayShouldMatch() {
-        assertJsonEquals("[[3],[2],[1]]", "[[1,2],[2,3],[2,4]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS));
+        assertJsonEquals(
+                "[[3],[2],[1]]", "[[1,2],[2,3],[2,4]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS));
     }
 
     @Test
     void arraysMatchShouldReportErrorCorrectlyWhenIgnoringExtraFieldsComplex() {
-        assertThatThrownBy(() -> assertJsonEquals("[[3],[2],[1]]", "[[1,2],[2,3],[4,4]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "[[3],[2],[1]]", "[[1,2],[2,3],[4,4]]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element [2] to actual element [2].
                 Array "[2]" has different content. Missing values: [1], expected: <[1]> but was: <[4,4]>
@@ -621,8 +671,12 @@ void arraysMatchShouldReportErrorCorrectlyWhenIgnoringExtraFieldsComplex() {
 
     @Test
     void arraysMatchShouldReportErrorCorrectlyWhenIgnoringExtraFieldsInEmbeddedObjects() {
-        assertThatThrownBy(() -> assertJsonEquals("[{\"a\":[\"b\"]},{\"a\":[\"a\"]}]", "[{\"a\":[\"b\",\"a\"]},{\"a\":[\"d\",\"c\"]}]", when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "[{\"a\":[\"b\"]},{\"a\":[\"a\"]}]",
+                        "[{\"a\":[\"b\",\"a\"]},{\"a\":[\"d\",\"c\"]}]",
+                        when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element [1] to actual element [1].
                 Array "[1].a" has different content. Missing values: ["a"], expected: <["a"]> but was: <["d","c"]>
@@ -632,26 +686,31 @@ void arraysMatchShouldReportErrorCorrectlyWhenIgnoringExtraFieldsInEmbeddedObjec
     @Test
     void shouldFailIfArrayContentIsDifferentMoreThaOneDifference() {
         RecordingDifferenceListener listener = new RecordingDifferenceListener();
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,4,5]}", when(IGNORING_ARRAY_ORDER).withDifferenceListener(listener)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[1,2,3]}",
+                        "{\"test\":[3,4,5]}",
+                        when(IGNORING_ARRAY_ORDER).withDifferenceListener(listener)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different content. Missing values: [1, 2], extra values: [4, 5], expected: <[1,2,3]> but was: <[3,4,5]>
                 """);
 
         assertThat(listener.getDifferenceList()).hasSize(4);
-        assertThat(listener.getDifferenceList()).extracting(toStringMethod()).containsExactly(
-            "MISSING 1 in test[0]",
-            "MISSING 2 in test[1]",
-            "EXTRA 4 in test[1]",
-            "EXTRA 5 in test[2]"
-        );
+        assertThat(listener.getDifferenceList())
+                .extracting(toStringMethod())
+                .containsExactly(
+                        "MISSING 1 in test[0]", "MISSING 2 in test[1]", "EXTRA 4 in test[1]", "EXTRA 5 in test[2]");
     }
 
     @Test
     void shouldFailIfArrayContentIsDifferentOnObjectArrays() {
         setOptions(IGNORING_ARRAY_ORDER);
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2},{\"key\":4}]}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}",
+                        "{\"test\":[{\"key\":3},{\"key\":2},{\"key\":4}]}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element test[0] to actual element test[2].
                 Different value found in node "test[2].key", expected: <1> but was: <4>.
@@ -667,7 +726,9 @@ void shouldIgnoreExtraFieldsIfRequested() {
     @Test
     void shouldIgnoreExtraFieldsInArray() {
         JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
-        assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}");
+        assertJsonEquals(
+                "{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}",
+                "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}");
     }
 
     @Test
@@ -685,8 +746,10 @@ void shouldIgnoreValuesInArray() {
     @Test
     void shouldFailIfIgnoringValuesButTypesAreDifferent() {
         setOptions(IGNORING_VALUES);
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":\"2\",\"c\":1}}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":\"2\",\"c\":1}}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test.b", expected: <2> but was: <"2">.
                 """);
@@ -695,8 +758,10 @@ void shouldFailIfIgnoringValuesButTypesAreDifferent() {
     @Test
     void shouldFailIfIgnoringValuesButTypesAreDifferentInArray() {
         setOptions(IGNORING_VALUES);
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":2},{\"c\":3}]}", "{\"test\":[{\"a\":1},{\"b\":\"2\"},{\"c\":3}]}"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[{\"a\":1},{\"b\":2},{\"c\":3}]}", "{\"test\":[{\"a\":1},{\"b\":\"2\"},{\"c\":3}]}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test[1].b", expected: <2> but was: <"2">.
                 """);
@@ -717,7 +782,7 @@ void assertPartNotEqualsShouldPass() {
     @Test
     void assertPartNotEqualsShouldFailWithCorrectMessage() {
         assertThatThrownBy(() -> assertJsonPartNotEquals("1", "{\"test\":{\"value\":1}}", "test.value"))
-            .hasMessage("Expected different values in node \"test.value\" but the values were equal.");
+                .hasMessage("Expected different values in node \"test.value\" but the values were equal.");
     }
 
     @Test
@@ -728,19 +793,21 @@ void assertNotEqualsShouldPass() {
     @Test
     void assertNotEqualsShouldFailWithCorrectMessage() {
         assertThatThrownBy(() -> assertJsonNotEquals("{\"test\":{\"value\":1}}", "{\"test\":{\"value\":1}}"))
-            .hasMessage("Expected different values but the values were equal.");
+                .hasMessage("Expected different values but the values were equal.");
     }
 
     @Test
     void strictStructureEqualsShouldFailOnNull() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": 3}", null, when(IGNORING_VALUES)))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"\", expected: <{\"test\":3}> but was: <null>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"\", expected: <{\"test\":3}> but was: <null>.\n");
     }
 
     @Test
     void strictStructureEqualsShouldFailOnDifferentType() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": 3}", "{\"test\": \"3\"}", when(IGNORING_VALUES)))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <3> but was: <\"3\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <3> but was: <\"3\">.\n");
     }
 
     @Test
@@ -765,13 +832,18 @@ void shouldNotAssertArraySize() {
 
     @Test
     void shouldCompareOnlyFirstElements() {
-        assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":2}]}", "{\"test\":[{\"a\":1},{\"b\":2},{\"c\":3}]}", when(IGNORING_EXTRA_ARRAY_ITEMS));
+        assertJsonEquals(
+                "{\"test\":[{\"a\":1},{\"b\":2}]}",
+                "{\"test\":[{\"a\":1},{\"b\":2},{\"c\":3}]}",
+                when(IGNORING_EXTRA_ARRAY_ITEMS));
     }
 
     @Test
     void shouldFailIfFirstElementsDoNotMatch() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[1,2,5,4]}", when(IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[1,2,3]}", "{\"test\":[1,2,5,4]}", when(IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test[2]", expected: <3> but was: <5>.
                 """);
@@ -779,18 +851,28 @@ void shouldFailIfFirstElementsDoNotMatch() {
 
     @Test
     void shouldIgnoreExtraItemInTheMiddleIfOrderIsIgnored() {
-        assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":2}]}", "{\"test\":[{\"a\":1},{\"c\":3},{\"b\":2}]}", when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
+        assertJsonEquals(
+                "{\"test\":[{\"a\":1},{\"b\":2}]}",
+                "{\"test\":[{\"a\":1},{\"c\":3},{\"b\":2}]}",
+                when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
     }
 
     @Test
     void shouldAcceptLongerShuffledArray() {
-        assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[5,5,4,4,3,3,2,2,1,1]}", when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
+        assertJsonEquals(
+                "{\"test\":[1,2,3]}",
+                "{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
+                when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
     }
 
     @Test
     void shouldFailIfOneValueIsMissing() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1,2,3,9]}", "{\"test\":[5,5,4,4,3,3,2,2,1,1]}", when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[1,2,3,9]}",
+                        "{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different content. Missing values: [9], expected: <[1,2,3,9]> but was: <[5,5,4,4,3,3,2,2,1,1]>
                 """);
@@ -798,8 +880,12 @@ void shouldFailIfOneValueIsMissing() {
 
     @Test
     void shouldFailIfIfExpectedIsLongerAndOrderIsIgnored() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[1,2,3,9]}", "{\"test\":[3,2,1]}", when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[1,2,3,9]}",
+                        "{\"test\":[3,2,1]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has invalid length, expected: <at least 4> but was: <3>.
                 Array "test" has different content. Missing values: [9], expected: <[1,2,3,9]> but was: <[3,2,1]>
@@ -808,8 +894,12 @@ void shouldFailIfIfExpectedIsLongerAndOrderIsIgnored() {
 
     @Test
     void shouldFailIfIfExpectedIsLongerAndOrderIsIgnoredAndTheItemsDoNotMatch() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[5,6,7,8]}", "{\"test\":[3,2,1]}", when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[5,6,7,8]}",
+                        "{\"test\":[3,2,1]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has invalid length, expected: <at least 4> but was: <3>.
                 Array "test" has different content. Missing values: [5, 6, 7, 8], expected: <[5,6,7,8]> but was: <[3,2,1]>
@@ -818,8 +908,12 @@ void shouldFailIfIfExpectedIsLongerAndOrderIsIgnoredAndTheItemsDoNotMatch() {
 
     @Test
     void shouldNotIgnoreExtraItemInTheMiddle() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":2}]}", "{\"test\":[{\"a\":1},{\"c\":3},{\"b\":2}]}", when(IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[{\"a\":1},{\"b\":2}]}",
+                        "{\"test\":[{\"a\":1},{\"c\":3},{\"b\":2}]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "test[1]", missing: "test[1].b", extra: "test[1].c", expected: <{"b":2}> but was: <{"c":3}>
                 """);
@@ -827,8 +921,12 @@ void shouldNotIgnoreExtraItemInTheMiddle() {
 
     @Test
     void shouldFailIfFirstElementsAreDifferent() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":2}]}", "{\"test\":[{\"a\":1},{\"b\":1}]}", when(IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[{\"a\":1},{\"b\":2}]}",
+                        "{\"test\":[{\"a\":1},{\"b\":1}]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test[1].b", expected: <2> but was: <1>.
                 """);
@@ -836,8 +934,12 @@ void shouldFailIfFirstElementsAreDifferent() {
 
     @Test
     void shouldFailIfExpectsMoreArrayItems() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":1},{\"c\":3}]}", "{\"test\":[{\"a\":1},{\"b\":1}]}", when(IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[{\"a\":1},{\"b\":1},{\"c\":3}]}",
+                        "{\"test\":[{\"a\":1},{\"b\":1}]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has invalid length, expected: <at least 3> but was: <2>.
                 Array "test" has different content. Missing values: [{"c":3}], expected: <[{"a":1},{"b":1},{"c":3}]> but was: <[{"a":1},{"b":1}]>
@@ -846,8 +948,12 @@ void shouldFailIfExpectsMoreArrayItems() {
 
     @Test
     void shouldFailIfExpectsMoreArrayItemsAndDifferentValues() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\":[{\"a\":1},{\"b\":2},{\"c\":3}]}", "{\"test\":[{\"a\":1},{\"b\":1}]}", when(IGNORING_EXTRA_ARRAY_ITEMS)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\":[{\"a\":1},{\"b\":2},{\"c\":3}]}",
+                        "{\"test\":[{\"a\":1},{\"b\":1}]}",
+                        when(IGNORING_EXTRA_ARRAY_ITEMS)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has invalid length, expected: <at least 3> but was: <2>.
                 Array "test" has different content. Missing values: [{"c":3}], expected: <[{"a":1},{"b":2},{"c":3}]> but was: <[{"a":1},{"b":1}]>
@@ -858,7 +964,8 @@ void shouldFailIfExpectsMoreArrayItemsAndDifferentValues() {
     @Test
     void shouldAddPathPrefixToPath() {
         assertThatThrownBy(() -> assertJsonPartEquals("2", jsonSource("{\"test\":1}", "$"), "test"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"$.test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"$.test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
@@ -879,7 +986,8 @@ void testRegex() {
     @Test
     void regexShouldFail() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"123\"}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test". Pattern "[A-Z]+" did not match "123".
                 """);
@@ -888,7 +996,8 @@ void regexShouldFail() {
     @Test
     void regexShouldFailOnNullGracefully() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": null}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test", expected: <"${json-unit.regex}[A-Z]+"> but was: <null>.
                 """);
@@ -897,7 +1006,8 @@ void regexShouldFailOnNullGracefully() {
     @Test
     void regexShouldFailOnNumberGracefully() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"#{json-unit.regex}[A-Z]+\"}", "{\"test\": 123}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test", expected: <"#{json-unit.regex}[A-Z]+"> but was: <123>.
                 """);
@@ -906,44 +1016,61 @@ void regexShouldFailOnNumberGracefully() {
     @Test
     void regexShouldFailOnNonexistingGracefully() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test2\": 123}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "test", extra: "test2", expected: <{"test":"${json-unit.regex}[A-Z]+"}> but was: <{"test2":123}>
                 """);
     }
 
-
     @Test
     void matcherShouldMatch() {
-        assertJsonEquals("{\"test\": \"${json-unit.matches:positive}\"}", "{\"test\":1}", JsonAssert.withMatcher("positive", greaterThan(valueOf(0))));
+        assertJsonEquals(
+                "{\"test\": \"${json-unit.matches:positive}\"}",
+                "{\"test\":1}",
+                JsonAssert.withMatcher("positive", greaterThan(valueOf(0))));
     }
 
     @Test
     void matcherParameterShouldBeIgnored() {
-        assertJsonEquals("{\"test\": \"${json-unit.matches:positive}param\"}", "{\"test\":1}", JsonAssert.withMatcher("positive", greaterThan(valueOf(0))));
+        assertJsonEquals(
+                "{\"test\": \"${json-unit.matches:positive}param\"}",
+                "{\"test\":1}",
+                JsonAssert.withMatcher("positive", greaterThan(valueOf(0))));
     }
 
     @Test
     void parametrizedMatcherShouldFail() {
         Matcher<?> divisionMatcher = new DivisionMatcher();
         try {
-            assertJsonEquals("{\"test\": \"${json-unit.matches:isDivisibleBy}3\"}", "{\"test\":5}", JsonAssert.withMatcher("isDivisibleBy", divisionMatcher));
+            assertJsonEquals(
+                    "{\"test\": \"${json-unit.matches:isDivisibleBy}3\"}",
+                    "{\"test\":5}",
+                    JsonAssert.withMatcher("isDivisibleBy", divisionMatcher));
         } catch (AssertionError e) {
-            assertEquals("JSON documents are different:\nMatcher \"isDivisibleBy\" does not match value 5 in node \"test\". It is not divisible by <3>\n", e.getMessage());
+            assertEquals(
+                    "JSON documents are different:\nMatcher \"isDivisibleBy\" does not match value 5 in node \"test\". It is not divisible by <3>\n",
+                    e.getMessage());
         }
     }
 
     @Test
     void parametrizedMatcherShouldMatch() {
         Matcher<?> divisionMatcher = new DivisionMatcher();
-        assertJsonEquals("{\"test\": \"${json-unit.matches:isDivisibleBy}3\"}", "{\"test\":6}", JsonAssert.withMatcher("isDivisibleBy", divisionMatcher));
+        assertJsonEquals(
+                "{\"test\": \"${json-unit.matches:isDivisibleBy}3\"}",
+                "{\"test\":6}",
+                JsonAssert.withMatcher("isDivisibleBy", divisionMatcher));
     }
 
     @Test
     void missingParameterShouldResultInEmptyString() {
         Matcher<?> divisionMatcher = new DivisionMatcher();
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"${json-unit.matches:isDivisibleBy}\"}", "{\"test\":6}", JsonAssert.withMatcher("isDivisibleBy", divisionMatcher)))
-            .isInstanceOf(NumberFormatException.class);
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\": \"${json-unit.matches:isDivisibleBy}\"}",
+                        "{\"test\":6}",
+                        JsonAssert.withMatcher("isDivisibleBy", divisionMatcher)))
+                .isInstanceOf(NumberFormatException.class);
     }
 
     @Test
@@ -952,44 +1079,39 @@ void shouldUseMultipleMatchers() {
         Matcher<?> emptyMatcher = empty();
 
         assertJsonEquals(
-            "{\"test\": \"${json-unit.matches:isDivisibleBy}3\", \"x\": \"${json-unit.matches:isEmpty}\"}",
-            "{\"test\":6, \"x\": []}",
-            JsonAssert
-                .withMatcher("isDivisibleBy", divisionMatcher)
-                .withMatcher("isEmpty", emptyMatcher)
-        );
-
+                "{\"test\": \"${json-unit.matches:isDivisibleBy}3\", \"x\": \"${json-unit.matches:isEmpty}\"}",
+                "{\"test\":6, \"x\": []}",
+                JsonAssert.withMatcher("isDivisibleBy", divisionMatcher).withMatcher("isEmpty", emptyMatcher));
     }
 
     @Test
     void matcherNameShouldBeparsedUntilFirstCurlyBrace() {
-        String expected =
-            "{ \"o\" : \"${json-unit.matches:embedded}{\\\"x\\\" : \\\"y\\\"}\" }";
-        String actual =
-            "{ \"o\" : \"{\\\"x\\\" : \\\"y\\\"}\" }";
-
-        JsonAssert.assertJsonEquals(expected, actual,
-            JsonAssert.withMatcher("embedded", new TrueMatcher()));
+        String expected = "{ \"o\" : \"${json-unit.matches:embedded}{\\\"x\\\" : \\\"y\\\"}\" }";
+        String actual = "{ \"o\" : \"{\\\"x\\\" : \\\"y\\\"}\" }";
 
+        JsonAssert.assertJsonEquals(expected, actual, JsonAssert.withMatcher("embedded", new TrueMatcher()));
     }
 
     @Test
     void parameterMatchingShouldWork() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\": [\"${json-unit.matches:eq}1\", \"${json-unit.matches:eq}2\"]}", "{\"test\":[2, 2]}", withMatcher("eq", new NumEqualsMatcher()).when(IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\": [\"${json-unit.matches:eq}1\", \"${json-unit.matches:eq}2\"]}",
+                        "{\"test\":[2, 2]}",
+                        withMatcher("eq", new NumEqualsMatcher()).when(IGNORING_ARRAY_ORDER)))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element test[0] to actual element test[1].
                 Matcher "eq" does not match value 2 in node "test[1]".\s
                 """);
     }
 
-
     static class DivisionMatcher extends BaseMatcher<Object> implements ParametrizedMatcher {
         private BigDecimal param;
 
         @Override
         public boolean matches(Object item) {
-            return ((BigDecimal)item).remainder(param).compareTo(ZERO) == 0;
+            return ((BigDecimal) item).remainder(param).compareTo(ZERO) == 0;
         }
 
         @Override
@@ -1022,9 +1144,7 @@ public void describeTo(Description description) {
         }
 
         @Override
-        public void describeMismatch(Object item, Description description) {
-
-        }
+        public void describeMismatch(Object item, Description description) {}
 
         @Override
         public void setParameter(String parameter) {
@@ -1047,9 +1167,7 @@ public void describeTo(Description description) {
         }
 
         @Override
-        public void describeMismatch(Object item, Description description) {
-
-        }
+        public void describeMismatch(Object item, Description description) {}
 
         @Override
         public void setParameter(String parameter) {
@@ -1057,25 +1175,36 @@ public void setParameter(String parameter) {
         }
     }
 
-
     @Test
     void pathShouldBeIgnoredForDifferentValue() {
-        assertJsonEquals("{\"root\":{\"test\":1, \"ignored\": 2}}", "{\"root\":{\"test\":1, \"ignored\": 1}}", JsonAssert.whenIgnoringPaths("root.ignored"));
+        assertJsonEquals(
+                "{\"root\":{\"test\":1, \"ignored\": 2}}",
+                "{\"root\":{\"test\":1, \"ignored\": 1}}",
+                JsonAssert.whenIgnoringPaths("root.ignored"));
     }
 
     @Test
     void pathShouldBeIgnoredForDifferentValueWithWhen() {
-        assertJsonEquals("{\"root\":{\"test\":1, \"ignored\": 2}}", "{\"root\":{\"test\":1, \"ignored\": 1}}", JsonAssert.when(path("root.ignored"), thenIgnore()));
+        assertJsonEquals(
+                "{\"root\":{\"test\":1, \"ignored\": 2}}",
+                "{\"root\":{\"test\":1, \"ignored\": 1}}",
+                JsonAssert.when(path("root.ignored"), thenIgnore()));
     }
 
     @Test
     void arrayWildcardForPathIgnoring() {
-        assertJsonEquals("[{\"a\":1, \"b\":0},{\"a\":2, \"b\":0}]", "[{\"a\":1, \"b\":2},{\"a\":2, \"b\":3}]", JsonAssert.whenIgnoringPaths("[*].b"));
+        assertJsonEquals(
+                "[{\"a\":1, \"b\":0},{\"a\":2, \"b\":0}]",
+                "[{\"a\":1, \"b\":2},{\"a\":2, \"b\":3}]",
+                JsonAssert.whenIgnoringPaths("[*].b"));
     }
 
     @Test
     void arrayWildcardForPathIgnoringArrayOrder() {
-        assertJsonEquals("[{\"a\":1, \"b\":0},{\"a\":2, \"b\":0}]", "[{\"a\":2, \"b\":2},{\"a\":1, \"b\":3}]", JsonAssert.whenIgnoringPaths("[*].b").when(IGNORING_ARRAY_ORDER));
+        assertJsonEquals(
+                "[{\"a\":1, \"b\":0},{\"a\":2, \"b\":0}]",
+                "[{\"a\":2, \"b\":2},{\"a\":1, \"b\":3}]",
+                JsonAssert.whenIgnoringPaths("[*].b").when(IGNORING_ARRAY_ORDER));
     }
 
     @Test
@@ -1085,7 +1214,8 @@ void inPathShouldWork() {
 
     @Test
     void arrayWildcardShouldWorkWhenIgnoringArrayOrder() {
-        String expected = """
+        String expected =
+                """
             {
               "calendars": [
                 {
@@ -1100,7 +1230,8 @@ void arrayWildcardShouldWorkWhenIgnoringArrayOrder() {
               ]
             }""";
 
-        String actual = """
+        String actual =
+                """
             {
               "calendars": [
                 {
@@ -1115,16 +1246,16 @@ void arrayWildcardShouldWorkWhenIgnoringArrayOrder() {
               ]
             }""";
 
-        assertJsonEquals(expected, actual,
-            JsonAssert.whenIgnoringPaths(
-                "calendars[*].dates[*].from"
-            ).when(IGNORING_ARRAY_ORDER)
-        );
+        assertJsonEquals(
+                expected,
+                actual,
+                JsonAssert.whenIgnoringPaths("calendars[*].dates[*].from").when(IGNORING_ARRAY_ORDER));
     }
 
     @Test
     void arrayWildcardForPathIgnoringMultidimensional() {
-        assertJsonEquals("[[1, 2], [3, 4], [5, 6]]", "[[2, 2], [2, 4], [2, 6]]", JsonAssert.whenIgnoringPaths("[*][0]"));
+        assertJsonEquals(
+                "[[1, 2], [3, 4], [5, 6]]", "[[2, 2], [2, 4], [2, 6]]", JsonAssert.whenIgnoringPaths("[*][0]"));
     }
 
     @Test
@@ -1132,19 +1263,25 @@ void multidimensionalArrayCompareFailure() {
         try {
             assertJsonEquals("[[1, 2], [3, 4], [5, 6]]", "[[2, 2], [2, 4], [2, 6]]");
         } catch (AssertionError e) {
-            assertEquals("""
+            assertEquals(
+                    """
                 JSON documents are different:
                 Different value found in node "[0][0]", expected: <1> but was: <2>.
                 Different value found in node "[1][0]", expected: <3> but was: <2>.
                 Different value found in node "[2][0]", expected: <5> but was: <2>.
-                """, e.getMessage());
+                """,
+                    e.getMessage());
         }
     }
 
     @Test
     void arrayWildcardForPathIgnoringFail() {
-        assertThatThrownBy(() -> assertJsonEquals("[{\"a\":1, \"b\":5},{\"a\":1, \"b\":5}]", "[{\"a\":1, \"b\":2},{\"a\":1, \"b\":3}]", whenIgnoringPaths("[*].a")))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "[{\"a\":1, \"b\":5},{\"a\":1, \"b\":5}]",
+                        "[{\"a\":1, \"b\":2},{\"a\":1, \"b\":3}]",
+                        whenIgnoringPaths("[*].a")))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "[0].b", expected: <5> but was: <2>.
                 Different value found in node "[1].b", expected: <5> but was: <3>.
@@ -1153,27 +1290,32 @@ void arrayWildcardForPathIgnoringFail() {
 
     @Test
     void ifMatcherDoesNotMatchReportDifference() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"${json-unit.matches:positive}\"}", "{\"test\":-1}", withMatcher("positive", greaterThan(valueOf(0)))))
-            .hasMessage("JSON documents are different:\nMatcher \"positive\" does not match value -1 in node \"test\". <-1> was less than <0>\n");
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"test\": \"${json-unit.matches:positive}\"}",
+                        "{\"test\":-1}",
+                        withMatcher("positive", greaterThan(valueOf(0)))))
+                .hasMessage(
+                        "JSON documents are different:\nMatcher \"positive\" does not match value -1 in node \"test\". <-1> was less than <0>\n");
     }
 
     @Test
     void failIfMatcherNotFound() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"${json-unit.matches:unknown}\"}", "{\"test\":-1}"))
-            .hasMessage("JSON documents are different:\nMatcher \"unknown\" not found.\n");
+                .hasMessage("JSON documents are different:\nMatcher \"unknown\" not found.\n");
     }
 
-
     @Test
     void testEqualsNodeFail() {
         assertThatThrownBy(() -> assertJsonEquals(readValue("{\"test\":1}"), "{\"test\": 2}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void testEqualsNodeStringFail() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":\"a\"}", readValue("{\"test\": \"b\"}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <\"a\"> but was: <\"b\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <\"a\"> but was: <\"b\">.\n");
     }
 
     @Test
@@ -1183,44 +1325,48 @@ protected void testBinary() {
 
     @Test
     void shouldCompareArrays() {
-        String actualFileM = "{\"skeletonKeys\":[" +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":81,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":47,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":120,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":110,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":93,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":136,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":156,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":96,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":247,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":8,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":124,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":162,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":182,\"child\":true}," +
-            "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false}," +
-            "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false}" +
-            "]}";
-
-        String expectedFileM = "{\"skeletonKeys\":[" +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":81,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":47,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":120,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":110,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":93,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":136,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":156,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":96,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":247,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":8,\"child\":true}," +
-            "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-3\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":124,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":162,\"child\":true}," +
-            "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":182,\"child\":true}," +
-            "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false}," +
-            "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false}" +
-            "]}";
-
-        assertThatThrownBy(() -> assertJsonEquals(actualFileM, expectedFileM, when(IGNORING_ARRAY_ORDER).whenIgnoringPaths("skeletonKeys[*].sortIndex")))
-            .hasMessage("""
+        String actualFileM = "{\"skeletonKeys\":["
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":81,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":47,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":120,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":110,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":93,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":136,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":156,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":96,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":247,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":8,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":124,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":162,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":182,\"child\":true},"
+                + "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false},"
+                + "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false}"
+                + "]}";
+
+        String expectedFileM = "{\"skeletonKeys\":["
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":81,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":47,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":120,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":110,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":93,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":136,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":156,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":96,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":247,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":8,\"child\":true},"
+                + "{\"contentId\":\"category::samplecategory\",\"namespace\":\"testcustomer-bulk-client-3\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":124,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":162,\"child\":true},"
+                + "{\"contentId\":\"product::product11\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":182,\"child\":true},"
+                + "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-2\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false},"
+                + "{\"contentId\":\"d04b643f-c74b-5f3f-8042-5a5346a2c34a\",\"namespace\":\"testcustomer-bulk-client-1\",\"type\":\"contributor\",\"dateString\":\"\",\"sortIndex\":0,\"child\":false}"
+                + "]}";
+
+        assertThatThrownBy(() -> assertJsonEquals(
+                        actualFileM,
+                        expectedFileM,
+                        when(IGNORING_ARRAY_ORDER).whenIgnoringPaths("skeletonKeys[*].sortIndex")))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found when comparing expected array element skeletonKeys[10] to actual element skeletonKeys[10].
                 Different value found in node "skeletonKeys[10].namespace", expected: <"testcustomer-bulk-client-2"> but was: <"testcustomer-bulk-client-3">.
@@ -1229,12 +1375,15 @@ void shouldCompareArrays() {
 
     @Test
     void shouldCompareLongArrays() {
-        String actual = "[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]";
+        String actual =
+                "[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]";
 
-        String expected = "[1,8,9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]";
+        String expected =
+                "[1,8,9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]";
 
         assertThatThrownBy(() -> assertJsonEquals(actual, expected, when(IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "" has different content. Missing values: [1, 1], extra values: [8, 9], expected: <[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]> but was: <[1,8,9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]>
                 """);
@@ -1242,12 +1391,15 @@ void shouldCompareLongArrays() {
 
     @Test
     void shouldCompareLongArraysWithTwoEquivaletSets() {
-        String actual = "[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]";
+        String actual =
+                "[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]";
 
-        String expected = "[1,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,9,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]";
+        String expected =
+                "[1,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,9,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]";
 
         assertThatThrownBy(() -> assertJsonEquals(actual, expected, when(IGNORING_ARRAY_ORDER)))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "" has different content. Missing values: [1, 5], extra values: [8, 9], expected: <[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]> but was: <[1,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,9,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]>
                 """);
@@ -1260,17 +1412,20 @@ void shouldUseRightValuesWhenComparingArrays() {
 
     @Test
     void shouldIgnoreArrayOrderInSpecificPath() {
-        assertJsonEquals("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]", "[{\"b\":[2,1,3]},{\"b\":[6,4,5]}]",
-            when(path("[*].b"), then(IGNORING_ARRAY_ORDER)));
+        assertJsonEquals(
+                "[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]",
+                "[{\"b\":[2,1,3]},{\"b\":[6,4,5]}]",
+                when(path("[*].b"), then(IGNORING_ARRAY_ORDER)));
     }
 
     @Test
     void shouldNotIgnoreArrayOrderWhenNotSpecified() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]",
-            "[{\"b\":[6,4,5]},{\"b\":[2,1,3]}]",
-            when(path("[*].b"), then(IGNORING_ARRAY_ORDER))))
-            .hasMessage("""
+                        "[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]",
+                        "[{\"b\":[6,4,5]},{\"b\":[2,1,3]}]",
+                        when(path("[*].b"), then(IGNORING_ARRAY_ORDER))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "[0].b" has different content. Missing values: [1, 2, 3], extra values: [6, 4, 5], expected: <[1,2,3]> but was: <[6,4,5]>
                 Array "[1].b" has different content. Missing values: [4, 5, 6], extra values: [2, 1, 3], expected: <[4,5,6]> but was: <[2,1,3]>
@@ -1279,23 +1434,29 @@ void shouldNotIgnoreArrayOrderWhenNotSpecified() {
 
     @Test
     void shouldExcludeIgnoringArrayOrderFromPath() {
-        assertJsonEquals("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]", "[{\"b\":[4,5,6]},{\"b\":[1,2,3]}]",
-            when(IGNORING_ARRAY_ORDER).when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER)));
+        assertJsonEquals(
+                "[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]",
+                "[{\"b\":[4,5,6]},{\"b\":[1,2,3]}]",
+                when(IGNORING_ARRAY_ORDER).when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER)));
     }
 
     @Test
     void shouldExcludeIgnoringArrayOrderFromPathAndIgnoreInRoot() {
-        assertJsonEquals("[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]", "[{\"b\":[4,5,6]},{\"b\":[1,2,3]}]",
-            when(rootPath(), then(IGNORING_ARRAY_ORDER)).when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER)));
+        assertJsonEquals(
+                "[{\"b\":[1,2,3]},{\"b\":[4,5,6]}]",
+                "[{\"b\":[4,5,6]},{\"b\":[1,2,3]}]",
+                when(rootPath(), then(IGNORING_ARRAY_ORDER)).when(path("[*].b"), thenNot(IGNORING_ARRAY_ORDER)));
     }
 
     @Test
     void shouldIgnoreArrayOrderEverywhereButTheFirstElement() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "[{\"b\":[1,2,3]},{\"b\":[4,5,6]},{\"b\":[7,8,9]}]",
-            "[{\"b\":[1,3,2]},{\"b\":[5,4,6]},{\"b\":[8,7,9]}]",
-            when(path("[*].b"), then(IGNORING_ARRAY_ORDER)).when(path("[0].b"), thenNot(IGNORING_ARRAY_ORDER))))
-            .hasMessage("""
+                        "[{\"b\":[1,2,3]},{\"b\":[4,5,6]},{\"b\":[7,8,9]}]",
+                        "[{\"b\":[1,3,2]},{\"b\":[5,4,6]},{\"b\":[8,7,9]}]",
+                        when(path("[*].b"), then(IGNORING_ARRAY_ORDER))
+                                .when(path("[0].b"), thenNot(IGNORING_ARRAY_ORDER))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "[0].b[1]", expected: <2> but was: <3>.
                 Different value found in node "[0].b[2]", expected: <3> but was: <2>.
@@ -1305,22 +1466,22 @@ void shouldIgnoreArrayOrderEverywhereButTheFirstElement() {
     @Test
     void shouldIgnoreArrayOrderInSeveralSpecificPaths() {
         assertJsonEquals(
-            "[{\"b\":[1,2,3],\"c\":[-1,-2,-3]},{\"b\":[4,5,6],\"c\":[-4,-5,-6]}]",
-            "[{\"b\":[3,1,2],\"c\":[-2,-3,-1]},{\"b\":[6,5,4],\"c\":[-5,-4,-6]}]",
-            when(paths("[*].b", "[*].c"), then(IGNORING_ARRAY_ORDER)));
+                "[{\"b\":[1,2,3],\"c\":[-1,-2,-3]},{\"b\":[4,5,6],\"c\":[-4,-5,-6]}]",
+                "[{\"b\":[3,1,2],\"c\":[-2,-3,-1]},{\"b\":[6,5,4],\"c\":[-5,-4,-6]}]",
+                when(paths("[*].b", "[*].c"), then(IGNORING_ARRAY_ORDER)));
     }
 
     @Test
     void shouldTreatNullAsAbsentInSpecificPath() {
-        assertJsonEquals("{\"a\":1}", "{\"a\":1,\"b\":null}",
-            when(path("b"), then(TREATING_NULL_AS_ABSENT)));
+        assertJsonEquals("{\"a\":1}", "{\"a\":1,\"b\":null}", when(path("b"), then(TREATING_NULL_AS_ABSENT)));
     }
 
     @Test
     void shouldNotTreatNullAsAbsentWhenNotSpecified() {
-        assertThatThrownBy(() -> assertJsonEquals("{\"a\":1}", "{\"a\":1,\"b\":null,\"c\":null}",
-            when(path("b"), then(TREATING_NULL_AS_ABSENT))))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertJsonEquals(
+                        "{\"a\":1}", "{\"a\":1,\"b\":null,\"c\":null}", when(path("b"), then(TREATING_NULL_AS_ABSENT))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", extra: "c", expected: <{"a":1}> but was: <{"a":1,"b":null,"c":null}>
                 """);
@@ -1328,17 +1489,18 @@ void shouldNotTreatNullAsAbsentWhenNotSpecified() {
 
     @Test
     void shouldIgnoreExtraFieldsInSpecificPath() {
-        assertJsonEquals("{\"a\":{\"a1\":1}}", "{\"a\":{\"a1\":1,\"a2\":2}}",
-            when(path("a"), then(IGNORING_EXTRA_FIELDS)));
+        assertJsonEquals(
+                "{\"a\":{\"a1\":1}}", "{\"a\":{\"a1\":1,\"a2\":2}}", when(path("a"), then(IGNORING_EXTRA_FIELDS)));
     }
 
     @Test
     void shouldNotIgnoreExtraFieldsWhenNotSpecified() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "{\"a\":{\"a1\":1},\"b\":{\"b1\":1}}",
-            "{\"a\":{\"a1\":1,\"a2\":2},\"b\":{\"b1\":1,\"b2\":2}}",
-            when(path("a"), then(IGNORING_EXTRA_FIELDS))))
-            .hasMessage("""
+                        "{\"a\":{\"a1\":1},\"b\":{\"b1\":1}}",
+                        "{\"a\":{\"a1\":1,\"a2\":2},\"b\":{\"b1\":1,\"b2\":2}}",
+                        when(path("a"), then(IGNORING_EXTRA_FIELDS))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "b", extra: "b.b2", expected: <{"b1":1}> but was: <{"b1":1,"b2":2}>
                 """);
@@ -1346,17 +1508,17 @@ void shouldNotIgnoreExtraFieldsWhenNotSpecified() {
 
     @Test
     void shouldIgnoreExtraArrayItemsInSpecificPath() {
-        assertJsonEquals("{\"a\":[1,2]}", "{\"a\":[1,2,3]}",
-            when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS)));
+        assertJsonEquals("{\"a\":[1,2]}", "{\"a\":[1,2,3]}", when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS)));
     }
 
     @Test
     void shouldNotIgnoreExtraArrayItemsWhenNotSpecified() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "{\"a\":[1,2],\"b\":[1,2]}",
-            "{\"a\":[1,2,3],\"b\":[1,2,3]}",
-            when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS))))
-            .hasMessage("""
+                        "{\"a\":[1,2],\"b\":[1,2]}",
+                        "{\"a\":[1,2,3],\"b\":[1,2,3]}",
+                        when(path("a"), then(IGNORING_EXTRA_ARRAY_ITEMS))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "b" has different length, expected: <2> but was: <3>.
                 Array "b" has different content. Extra values: [3], expected: <[1,2]> but was: <[1,2,3]>
@@ -1365,18 +1527,20 @@ void shouldNotIgnoreExtraArrayItemsWhenNotSpecified() {
 
     @Test
     void shouldIgnoreValuesInSpecificPath() {
-        assertJsonEquals("{\"a\":1,\"b\":\"string\"}",
-            "{\"a\":2,\"b\":\"string2\"}",
-            when(paths("a", "b"), then(IGNORING_VALUES)));
+        assertJsonEquals(
+                "{\"a\":1,\"b\":\"string\"}",
+                "{\"a\":2,\"b\":\"string2\"}",
+                when(paths("a", "b"), then(IGNORING_VALUES)));
     }
 
     @Test
     void shouldNotIgnoreValuesWhenNotSpecified() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "{\"a\":1,\"b\":\"string\",\"c\":2}",
-            "{\"a\":2,\"b\":\"string2\",\"c\":3}",
-            when(paths("a", "b"), then(IGNORING_VALUES))))
-            .hasMessage("""
+                        "{\"a\":1,\"b\":\"string\",\"c\":2}",
+                        "{\"a\":2,\"b\":\"string2\",\"c\":3}",
+                        when(paths("a", "b"), then(IGNORING_VALUES))))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "c", expected: <2> but was: <3>.
                 """);
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonFluentAssertTest.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonFluentAssertTest.java
index ef4ea75d1..624fe7885 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonFluentAssertTest.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonFluentAssertTest.java
@@ -15,11 +15,6 @@
  */
 package net.javacrumbs.jsonunit.test.base;
 
-import net.javacrumbs.jsonunit.core.Option;
-import org.junit.jupiter.api.Test;
-
-import java.io.StringReader;
-
 import static java.math.BigDecimal.valueOf;
 import static net.javacrumbs.jsonunit.JsonMatchers.jsonEquals;
 import static net.javacrumbs.jsonunit.JsonMatchers.jsonPartEquals;
@@ -47,29 +42,35 @@
 import static org.hamcrest.Matchers.lessThanOrEqualTo;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.io.StringReader;
+import net.javacrumbs.jsonunit.core.Option;
+import org.junit.jupiter.api.Test;
+
 public abstract class AbstractJsonFluentAssertTest {
     @Test
     void testAssertString() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertDifferentType() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":\"1\"}").node("test").isEqualTo("1"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <\"1\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <\"1\">.\n");
     }
 
     @Test
     void testAssertDifferentTypeInt() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":\"1\"}").node("test").isEqualTo(1))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <\"1\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <\"1\">.\n");
     }
 
     @Test
     void shouldCompareDecimals() {
-        assertThatJson("{\"a\": 1.0, \"b\": 1.00}")
-            .node("b").isEqualTo("1.00");
+        assertThatJson("{\"a\": 1.0, \"b\": 1.00}").node("b").isEqualTo("1.00");
     }
 
     @Test
@@ -79,34 +80,26 @@ void testAssertTolerance() {
 
     @Test
     void shouldAssertEmptyArray() {
-        assertThatJson("{\"root\":[]}")
-                .node("root")
-                .isArray()
-                .isEmpty();
+        assertThatJson("{\"root\":[]}").node("root").isArray().isEmpty();
     }
 
     @Test
     void shouldFailOnNonEmptyArray() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":[1]}")
-                .node("root")
-                .isArray()
-                .isEmpty()).hasMessage("Node \"root\" is not an empty array.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"root\":[1]}").node("root").isArray().isEmpty())
+                .hasMessage("Node \"root\" is not an empty array.");
     }
 
     @Test
     void shouldAssertNonEmptyArray() {
-        assertThatJson("{\"root\":[1]}")
-                .node("root")
-                .isArray()
-                .isNotEmpty();
+        assertThatJson("{\"root\":[1]}").node("root").isArray().isNotEmpty();
     }
 
     @Test
     void shouldAssertNonEmptyArrayFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":[]}")
-                .node("root")
-                .isArray()
-                .isNotEmpty()).hasMessage("Node \"root\" is an empty array.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"root\":[]}").node("root").isArray().isNotEmpty())
+                .hasMessage("Node \"root\" is an empty array.");
     }
 
     @Test
@@ -126,32 +119,44 @@ void testAssertToleranceDirect() {
 
     @Test
     void testAssertToleranceFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":1.1}").node("test").withTolerance(0.001).isEqualTo(1))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <1.1>, difference is 0.1, tolerance is 0.001\n");
+        assertThatThrownBy(() -> assertThatJson("{\"test\":1.1}")
+                        .node("test")
+                        .withTolerance(0.001)
+                        .isEqualTo(1))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <1.1>, difference is 0.1, tolerance is 0.001\n");
     }
 
     @Test
     void testAssertZeroToleranceFailure() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":1.1}").node("test").withTolerance(0.0).isEqualTo(1))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <1.1>.\n");
+        assertThatThrownBy(() -> assertThatJson("{\"test\":1.1}")
+                        .node("test")
+                        .withTolerance(0.0)
+                        .isEqualTo(1))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <1.1>.\n");
     }
 
     @Test
     void testAssertNode() {
         assertThatThrownBy(() -> assertThatJson(readValue("{\"test\":1}")).isEqualTo(readValue("{\"test\":2}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertNodeInExpectOnly() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").isEqualTo(readValue("{\"test\":2}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertReader() {
-        assertThatThrownBy(() -> assertThatJson(new StringReader("{\"test\":1}")).isEqualTo(new StringReader("{\"test\":2}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson(new StringReader("{\"test\":1}")).isEqualTo(new StringReader("{\"test\":2}")))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
@@ -187,31 +192,41 @@ void testOkNull() {
     @Test
     void testNotEqualTo() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").isNotEqualTo("{\"test\": 1}"))
-            .hasMessage("JSON is equal.");
+                .hasMessage("JSON is equal.");
     }
 
     @Test
     void testAssertPath() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").isEqualTo("2"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testAssertPathWithDescription() {
-        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$")).node("test").isEqualTo("2"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"$.test\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$"))
+                        .node("test")
+                        .isEqualTo("2"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"$.test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testPresentWithDescription() {
-        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$")).node("test2").isPresent())
-            .hasMessage("Different value found in node \"$.test2\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(() -> assertThatJson(jsonSource("{\"test\":1}", "$"))
+                        .node("test2")
+                        .isPresent())
+                .hasMessage(
+                        "Different value found in node \"$.test2\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
     void testAssertPathArray() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[0]").isEqualTo(2))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"root.test[0]\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                        .node("root.test[0]")
+                        .isEqualTo(2))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"root.test[0]\", expected: <2> but was: <1>.\n");
     }
 
     @Test
@@ -219,58 +234,66 @@ void testAssertPathArrayOk() {
         assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[1]").isEqualTo(2);
     }
 
-
     @Test
     void testLongPaths() {
-        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":1}}").node("root.test").isEqualTo("2"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"root.test\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() -> assertThatJson("{\"root\":{\"test\":1}}")
+                        .node("root.test")
+                        .isEqualTo("2"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"root.test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testMoreNodes() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}").node("test1").isEqualTo(2).node("test2").isEqualTo(2))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test2\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}")
+                        .node("test1")
+                        .isEqualTo(2)
+                        .node("test2")
+                        .isEqualTo(2))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test2\", expected: <2> but was: <1>.\n");
     }
 
     @Test
     void testCompareArrays() {
-        assertThatJson("[{\"b\": 10}]")
-            .isEqualTo(json("[{\"b\": 10}]"));
+        assertThatJson("[{\"b\": 10}]").isEqualTo(json("[{\"b\": 10}]"));
     }
 
     @Test
     void testCompareArraysIgnoringChildOrder() {
         assertThatJson("[[1,2],[3,4],[5,6]]")
-            .when(path("[*]"), then(IGNORING_ARRAY_ORDER))
-            .isEqualTo(json("[[2,1],[4,3],[6,5]]"));
+                .when(path("[*]"), then(IGNORING_ARRAY_ORDER))
+                .isEqualTo(json("[[2,1],[4,3],[6,5]]"));
     }
 
     @Test
     void testCompareDifferentArraysIgnoringChildOrder() {
         assertThatJson("[[1,2],[3,4],[5,6]]")
-            .when(path("[*]"), then(IGNORING_ARRAY_ORDER))
-            .isNotEqualTo(json("[[4,3],[6,5],[2,1]]"));
+                .when(path("[*]"), then(IGNORING_ARRAY_ORDER))
+                .isNotEqualTo(json("[[4,3],[6,5],[2,1]]"));
     }
 
     @Test
     void testCompareArraysIgnoringChildOrderAndExtraElements() {
         assertThatJson("[[1,2,3],[3,4,5],[5,6,7]]")
-            .when(path("[*]"), then(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS))
-            .isEqualTo(json("[[2,1],[4,3],[6,5]]"));
+                .when(path("[*]"), then(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS))
+                .isEqualTo(json("[[2,1],[4,3],[6,5]]"));
     }
 
     @Test
     void testCompareArraysIgnoringChildOrderAndParentExtraElements() {
         assertThatJson("[[1,2],[3,4],[5,6],[7,8]]")
-            .when(path("[*]"), then(IGNORING_ARRAY_ORDER))
-            .when(rootPath(), then(IGNORING_EXTRA_ARRAY_ITEMS))
-            .isEqualTo(json("[[2,1],[4,3],[6,5]]"));
+                .when(path("[*]"), then(IGNORING_ARRAY_ORDER))
+                .when(rootPath(), then(IGNORING_EXTRA_ARRAY_ITEMS))
+                .isEqualTo(json("[[2,1],[4,3],[6,5]]"));
     }
 
     @Test
     void testNodeAbsent() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}").node("test2").isAbsent())
-            .hasMessage("Different value found in node \"test2\", expected: <node to be absent> but was: <1>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}")
+                        .node("test2")
+                        .isAbsent())
+                .hasMessage("Different value found in node \"test2\", expected: <node to be absent> but was: <1>.");
     }
 
     @Test
@@ -280,13 +303,19 @@ void testNodeAbsentOk() {
 
     @Test
     void shouldTreatNullAsAbsent() {
-        assertThatJson("{\"a\":1, \"b\": null}").when(Option.TREATING_NULL_AS_ABSENT).node("b").isAbsent();
+        assertThatJson("{\"a\":1, \"b\": null}")
+                .when(Option.TREATING_NULL_AS_ABSENT)
+                .node("b")
+                .isAbsent();
     }
 
     @Test
     void testNodePresent() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}").node("test3").isPresent())
-            .hasMessage("Different value found in node \"test3\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":1}")
+                        .node("test3")
+                        .isPresent())
+                .hasMessage(
+                        "Different value found in node \"test3\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -301,25 +330,34 @@ void testNodePresentNull() {
 
     @Test
     void isPresentShouldTreatNullAsAbsentWhenSpecified() {
-        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":null}").when(TREATING_NULL_AS_ABSENT).node("test2").isPresent())
-            .hasMessage("Different value found in node \"test2\", expected: <node to be present> but was: <missing>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test1\":2, \"test2\":null}")
+                        .when(TREATING_NULL_AS_ABSENT)
+                        .node("test2")
+                        .isPresent())
+                .hasMessage(
+                        "Different value found in node \"test2\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
     void shouldAllowWeirdCharsInArrayPattern() {
-        assertThatJson("""
+        assertThatJson(
+                        """
             {"root": {
               "@id" : "urn:uuid:50aa37c0-eef0-4d72-9f32-17ebbcf17c10",
               "@graph" : [
                 { "foo" : "bar" }
               ]
-            }}""").node("root.@graph[0].foo").isEqualTo("bar");
+            }}""")
+                .node("root.@graph[0].foo")
+                .isEqualTo("bar");
     }
 
     @Test
     void testMessage() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":1}").as("Test is different").isEqualTo("{\"test\":2}"))
-            .hasMessage("[Test is different] JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":1}").as("Test is different").isEqualTo("{\"test\":2}"))
+                .hasMessage(
+                        "[Test is different] JSON documents are different:\nDifferent value found in node \"test\", expected: <2> but was: <1>.\n");
     }
 
     @Test
@@ -327,7 +365,6 @@ void testIgnore() {
         assertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
     }
 
-
     @Test
     void testIgnoreHash() {
         assertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"#{json-unit.ignore}\"}");
@@ -350,20 +387,25 @@ void anyNumberShouldAcceptAFloat() {
 
     @Test
     void anyNumberShouldFailOnString() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":\"one\"}").isEqualTo("{\"test\":\"#{json-unit.any-number}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <\"one\">.\n");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":\"one\"}").isEqualTo("{\"test\":\"#{json-unit.any-number}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <\"one\">.\n");
     }
 
     @Test
     void anyNumberShouldFailOnNull() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":null}").isEqualTo("{\"test\":\"${json-unit.any-number}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <null>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <null>.\n");
     }
 
     @Test
     void anyNumberShouldFailOnObject() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-number}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <{\"a\":1}>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-number}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a number> but was: <{\"a\":1}>.\n");
     }
 
     @Test
@@ -373,20 +415,25 @@ void anyBooleanShouldAcceptTrue() {
 
     @Test
     void anyBooleanShouldFailOnString() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":\"true\"}").isEqualTo("{\"test\":\"#{json-unit.any-boolean}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a boolean> but was: <\"true\">.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":\"true\"}").isEqualTo("{\"test\":\"#{json-unit.any-boolean}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a boolean> but was: <\"true\">.\n");
     }
 
     @Test
     void anyBooleanShouldFailOnNull() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":null}").isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a boolean> but was: <null>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a boolean> but was: <null>.\n");
     }
 
     @Test
     void anyBooleanShouldFailOnObject() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a boolean> but was: <{\"a\":1}>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a boolean> but was: <{\"a\":1}>.\n");
     }
 
     @Test
@@ -397,19 +444,23 @@ void anyStringShouldAcceptAString() {
     @Test
     void anyStringShouldFailOnBoolean() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":true}").isEqualTo("{\"test\":\"#{json-unit.any-string}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a string> but was: <true>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a string> but was: <true>.\n");
     }
 
     @Test
     void anyStringShouldFailOnNull() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":null}").isEqualTo("{\"test\":\"${json-unit.any-string}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a string> but was: <null>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a string> but was: <null>.\n");
     }
 
     @Test
     void anyStringShouldFailOnObject() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-string}\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <a string> but was: <{\"a\":1}>.\n");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":1}}").isEqualTo("{\"test\":\"${json-unit.any-string}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <a string> but was: <{\"a\":1}>.\n");
     }
 
     @Test
@@ -420,80 +471,98 @@ void emptinessCheck() {
     @Test
     void ifMatcherDoesNotMatchReportDifference() {
         RecordingDifferenceListener listener = new RecordingDifferenceListener();
-        assertThatThrownBy(() -> assertThatJson("{\"test\":-1}").withMatcher("positive", greaterThan(valueOf(0))).withDifferenceListener(listener).isEqualTo("{\"test\": \"#{json-unit.matches:positive}\"}"))
-            .hasMessage("JSON documents are different:\nMatcher \"positive\" does not match value -1 in node \"test\". <-1> was less than <0>\n");
+        assertThatThrownBy(() -> assertThatJson("{\"test\":-1}")
+                        .withMatcher("positive", greaterThan(valueOf(0)))
+                        .withDifferenceListener(listener)
+                        .isEqualTo("{\"test\": \"#{json-unit.matches:positive}\"}"))
+                .hasMessage(
+                        "JSON documents are different:\nMatcher \"positive\" does not match value -1 in node \"test\". <-1> was less than <0>\n");
         assertThat(listener.getDifferenceList()).hasSize(1);
-        assertThat(listener.getDifferenceList().get(0).toString()).isEqualTo("DIFFERENT Expected #{json-unit.matches:positive} in test got -1 in test");
+        assertThat(listener.getDifferenceList().get(0).toString())
+                .isEqualTo("DIFFERENT Expected #{json-unit.matches:positive} in test got -1 in test");
     }
 
     @Test
     void testLogging() {
         assertThatJson("[\"foo\", \"bar\"]")
-        .isArray()
-        .ofLength(2)
-        .thatContains("foo")
-        .thatContains("bar");
+                .isArray()
+                .ofLength(2)
+                .thatContains("foo")
+                .thatContains("bar");
     }
 
-
     @Test
     void shoulEscapeDot() {
-        assertThatJson("{\"name.with.dot\": \"value\"}").node("name\\.with\\.dot").isStringEqualTo("value");
+        assertThatJson("{\"name.with.dot\": \"value\"}")
+                .node("name\\.with\\.dot")
+                .isStringEqualTo("value");
     }
 
     @Test
     void shoulEscapeDotWithArray() {
-        assertThatJson("{\"errors\":{\"days[0].date\":[\"validation.failed\"]}}").node("errors.days[0]\\.date").isArray();
+        assertThatJson("{\"errors\":{\"days[0].date\":[\"validation.failed\"]}}")
+                .node("errors.days[0]\\.date")
+                .isArray();
     }
 
     @Test
     void comparisonShouldFailOnDifferentType() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"1\"}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <\"1\"> but was: <1>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <\"1\"> but was: <1>.\n");
     }
 
     @Test
     void pathShouldBeIgnoredForExtraKey() {
-        assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}").whenIgnoringPaths("root.ignored").isEqualTo("{\"root\":{\"test\":1}}");
+        assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}")
+                .whenIgnoringPaths("root.ignored")
+                .isEqualTo("{\"root\":{\"test\":1}}");
     }
 
     @Test
     void pathShouldBeIgnoredForDifferentValue() {
-        assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}").whenIgnoringPaths("root.ignored").isEqualTo("{\"root\":{\"test\":1, \"ignored\": 2}}");
+        assertThatJson("{\"root\":{\"test\":1, \"ignored\": 1}}")
+                .whenIgnoringPaths("root.ignored")
+                .isEqualTo("{\"root\":{\"test\":1, \"ignored\": 2}}");
     }
 
     @Test
     void testEqualsToArray() {
-        assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo(new int[]{1, 2, 3});
+        assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo(new int[] {1, 2, 3});
     }
 
     @Test
     void testEqualsToDoubleArray() {
-        assertThatJson("{\"test\":[1.0,2.0,3.0]}").node("test").isEqualTo(new double[]{1, 2, 3});
+        assertThatJson("{\"test\":[1.0,2.0,3.0]}").node("test").isEqualTo(new double[] {1, 2, 3});
     }
 
     @Test
     void isArrayShouldFailIfArrayDoesNotExist() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test2").isArray())
-            .hasMessage("Different value found in node \"test2\", expected: <array> but was: <missing>.");
+                .hasMessage("Different value found in node \"test2\", expected: <array> but was: <missing>.");
     }
 
     @Test
     void isArrayShouldFailIfItIsNotArray() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":\"1\"}").node("test").isArray())
-            .hasMessage("Node \"test\" has invalid type, expected: <array> but was: <\"1\">.");
+                .hasMessage("Node \"test\" has invalid type, expected: <array> but was: <\"1\">.");
     }
 
     @Test
     void arrayOfLengthShouldFailOnIncorrectSize() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").isArray().ofLength(2))
-            .hasMessage("Node \"test\" has invalid length, expected: <2> but was: <3>.");
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}")
+                        .node("test")
+                        .isArray()
+                        .ofLength(2))
+                .hasMessage("Node \"test\" has invalid length, expected: <2> but was: <3>.");
     }
 
     @Test
     void shouldReportExtraArrayItemsWhenNotIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo("[1]"))
-            .hasMessage("""
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":[1,2,3]}").node("test").isEqualTo("[1]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <1> but was: <3>.
                 Array "test" has different content. Extra values: [2, 3], expected: <[1]> but was: <[1,2,3]>
@@ -502,8 +571,12 @@ void shouldReportExtraArrayItemsWhenNotIgnoringOrder() {
 
     @Test
     void shouldReportExtraArrayItemsWhenIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").when(IGNORING_ARRAY_ORDER).isEqualTo("[1]"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}")
+                        .node("test")
+                        .when(IGNORING_ARRAY_ORDER)
+                        .isEqualTo("[1]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <1> but was: <3>.
                 Array "test" has different content. Missing values: [], extra values: [2, 3], expected: <[1]> but was: <[1,2,3]>
@@ -513,7 +586,8 @@ void shouldReportExtraArrayItemsWhenIgnoringOrder() {
     @Test
     void shouldReportMissingArrayItemsWhenNotIgnoringOrder() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":[1]}").node("test").isEqualTo("[1, 2, 3]"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <3> but was: <1>.
                 Array "test" has different content. Missing values: [2, 3], expected: <[1,2,3]> but was: <[1]>
@@ -522,8 +596,12 @@ void shouldReportMissingArrayItemsWhenNotIgnoringOrder() {
 
     @Test
     void shouldReportMissingArrayItemsWhenIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1]}").node("test").when(IGNORING_ARRAY_ORDER).isEqualTo("[1, 2, 3]"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[1]}")
+                        .node("test")
+                        .when(IGNORING_ARRAY_ORDER)
+                        .isEqualTo("[1, 2, 3]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <3> but was: <1>.
                 Array "test" has different content. Missing values: [2, 3], extra values: [], expected: <[1,2,3]> but was: <[1]>
@@ -532,8 +610,11 @@ void shouldReportMissingArrayItemsWhenIgnoringOrder() {
 
     @Test
     void shouldReportExtraArrayItemsAndDifferencesWhenNotIgnoringOrder() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[\"x\",\"b\",\"c\"]}").node("test").isEqualTo("[\"a\"]"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[\"x\",\"b\",\"c\"]}")
+                        .node("test")
+                        .isEqualTo("[\"a\"]"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "test" has different length, expected: <1> but was: <3>.
                 Array "test" has different content. Extra values: ["b", "c"], expected: <["a"]> but was: <["x","b","c"]>
@@ -549,24 +630,32 @@ void negativeArrayIndexShouldCountBackwards() {
     @Test
     void negativeArrayIndexShouldCountBackwardsAndReportFailure() {
         try {
-            assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[-3]").isEqualTo(3);
+            assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                    .node("root.test[-3]")
+                    .isEqualTo(3);
         } catch (AssertionError e) {
-            assertEquals("""
+            assertEquals(
+                    """
                 JSON documents are different:
                 Different value found in node "root.test[-3]", expected: <3> but was: <1>.
-                """, e.getMessage());
+                """,
+                    e.getMessage());
         }
     }
 
     @Test
     void negativeArrayIndexOutOfBounds() {
         try {
-            assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[-5]").isEqualTo(3);
+            assertThatJson("{\"root\":{\"test\":[1,2,3]}}")
+                    .node("root.test[-5]")
+                    .isEqualTo(3);
         } catch (AssertionError e) {
-            assertEquals("""
+            assertEquals(
+                    """
                 JSON documents are different:
                 Missing node in path "root.test[-5]".
-                """, e.getMessage());
+                """,
+                    e.getMessage());
         }
     }
 
@@ -575,22 +664,32 @@ void positiveArrayIndexOutOfBounds() {
         try {
             assertThatJson("{\"root\":{\"test\":[1,2,3]}}").node("root.test[5]").isEqualTo(3);
         } catch (AssertionError e) {
-            assertEquals("""
+            assertEquals(
+                    """
                 JSON documents are different:
                 Missing node in path "root.test[5]".
-                """, e.getMessage());
+                """,
+                    e.getMessage());
         }
     }
 
     @Test
     void arrayThatContainsShouldFailOnMissingNode() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[{\"id\":36},{\"id\":37},{\"id\":38}]}").node("test").isArray().thatContains("{\"id\":42}"))
-            .hasMessage("Node \"test\" is '[{\"id\":36}, {\"id\":37}, {\"id\":38}]', expected to contain '{\"id\":42}'.");
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[{\"id\":36},{\"id\":37},{\"id\":38}]}")
+                        .node("test")
+                        .isArray()
+                        .thatContains("{\"id\":42}"))
+                .hasMessage(
+                        "Node \"test\" is '[{\"id\":36}, {\"id\":37}, {\"id\":38}]', expected to contain '{\"id\":42}'.");
     }
 
     @Test
     void testContains() {
-        assertThatJson("[\"foo\", \"bar\"]").isArray().ofLength(2).thatContains("foo").thatContains("bar");
+        assertThatJson("[\"foo\", \"bar\"]")
+                .isArray()
+                .ofLength(2)
+                .thatContains("foo")
+                .thatContains("bar");
     }
 
     @Test
@@ -606,17 +705,18 @@ void arrayContainsShouldMatch() {
     @Test
     void testArrayShouldMatchRegardlessOfOrder() {
 
-        final String actual = "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"}],\"id\":123}]}";
-        final String expected = "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"}],\"id\":123}]}";
+        final String actual =
+                "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"}],\"id\":123}]}";
+        final String expected =
+                "{\"response\":[{\"attributes\":null,\"empolyees\":[{\"dob\":\"1985-01-11\",\"firstName\":\"Kate\",\"lastName\":\"Smith\"},{\"dob\":\"1986-02-12\",\"firstName\":\"Jason\",\"lastName\":\"Kowalski\"},{\"dob\":\"1987-03-21\",\"firstName\":\"Joe\",\"lastName\":\"Doe\"}],\"id\":123}]}";
 
         assertThatJson(actual).when(Option.IGNORING_ARRAY_ORDER).isEqualTo(expected);
     }
 
-
     @Test
     void intValueShouldFailIfDoesNotMatch() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").matches(equalTo(valueOf(2))))
-            .hasMessage("Node \"test\" does not match.\nExpected: <2>\n     but: was <1>");
+                .hasMessage("Node \"test\" does not match.\nExpected: <2>\n     but: was <1>");
     }
 
     @Test
@@ -624,14 +724,12 @@ void floatValueShouldMatch() {
         assertThatJson("{\"test\":1.10001}").node("test").matches(closeTo(valueOf(1.1), valueOf(0.001)));
     }
 
-
     @Test
     void floatValueShouldFailIfDoesNotMatch() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").matches(equalTo(valueOf(2))))
-            .hasMessage("Node \"test\" does not match.\nExpected: <2>\n     but: was <1>");
+                .hasMessage("Node \"test\" does not match.\nExpected: <2>\n     but: was <1>");
     }
 
-
     @Test
     void booleanValueShouldMatch() {
         assertThatJson("{\"test\":true}").node("test").matches(equalTo(true));
@@ -639,14 +737,16 @@ void booleanValueShouldMatch() {
 
     @Test
     void booleanValueShouldFailIfDoesNotMatch() {
-        assertThatThrownBy(() -> assertThatJson("{\"test2\":true}").node("test2").matches(equalTo(false)))
-            .hasMessage("Node \"test2\" does not match.\nExpected: <false>\n     but: was <true>");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test2\":true}").node("test2").matches(equalTo(false)))
+                .hasMessage("Node \"test2\" does not match.\nExpected: <false>\n     but: was <true>");
     }
 
     @Test
     void missingValueShouldFail() {
         assertThatThrownBy(() -> assertThatJson("{\"test2\":true}").node("test").matches(equalTo(false)))
-            .hasMessage("Different value found in node \"test\", expected: <node to be present> but was: <missing>.");
+                .hasMessage(
+                        "Different value found in node \"test\", expected: <node to be present> but was: <missing>.");
     }
 
     @Test
@@ -656,8 +756,9 @@ void stringValueShouldMatch() {
 
     @Test
     void stringValueShouldFailIfDoesNotMatch() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":\"one\"}").node("test").matches(equalTo("two")))
-            .hasMessage("Node \"test\" does not match.\nExpected: \"two\"\n     but: was \"one\"");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":\"one\"}").node("test").matches(equalTo("two")))
+                .hasMessage("Node \"test\" does not match.\nExpected: \"two\"\n     but: was \"one\"");
     }
 
     @Test
@@ -667,8 +768,9 @@ void nullValueShouldMatch() {
 
     @Test
     void nullValueShouldFailIfDoesNotMatch() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":\"one\"}").node("test").matches(equalTo(nullValue())))
-            .hasMessage("Node \"test\" does not match.\nExpected: <null>\n     but: was \"one\"");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":\"one\"}").node("test").matches(equalTo(nullValue())))
+                .hasMessage("Node \"test\" does not match.\nExpected: <null>\n     but: was \"one\"");
     }
 
     @Test
@@ -681,11 +783,12 @@ void arraySizeShouldMatch() {
         assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasSize(3));
     }
 
-
     @Test
     void arrayMatcherShouldFailIfNotFound() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(4)))
-            .hasMessage("""
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(4)))
+                .hasMessage(
+                        """
                 Node "test" does not match.
                 Expected: a collection containing <4>
                      but: mismatches were: [was <1>, was <2>, was <3>]""");
@@ -693,18 +796,25 @@ void arrayMatcherShouldFailIfNotFound() {
 
     @Test
     void objectShouldMatch() {
-        assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}").node("test").matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
+        assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
+                .node("test")
+                .matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
     }
 
     @Test
     void objectShouldMatchToMap() {
-        assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}").node("test").matches(hasItem(hasEntry("value", valueOf(1))));
+        assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
+                .node("test")
+                .matches(hasItem(hasEntry("value", valueOf(1))));
     }
 
     @Test
     void objectMatcherShouldFailIfNotFound() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}").node("test").matches(hasItem(jsonPartEquals("value", 4))))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
+                        .node("test")
+                        .matches(hasItem(jsonPartEquals("value", 4))))
+                .hasMessage(
+                        """
                 Node "test" does not match.
                 Expected: a collection containing 4 in "value"
                      but: mismatches were: [JSON documents are different:
@@ -719,33 +829,34 @@ void objectMatcherShouldFailIfNotFound() {
     @Test
     void isStringShouldFailIfItDoesNotExist() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test2").isString())
-            .hasMessage("Different value found in node \"test2\", expected: <string> but was: <missing>.");
+                .hasMessage("Different value found in node \"test2\", expected: <string> but was: <missing>.");
     }
 
-
     @Test
     void shouldChainStringEquals() {
         assertThatJson("{ \"key1\": \"[value1]\", \"key2\": \"[value2]\" }")
-         .node("key1").isStringEqualTo("[value1]")
-         .node("key2").isStringEqualTo("[value2]");
+                .node("key1")
+                .isStringEqualTo("[value1]")
+                .node("key2")
+                .isStringEqualTo("[value2]");
     }
 
     @Test
     void isStringShouldFailIfItIsNotAString() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").isString())
-            .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <1>.");
+                .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <1>.");
     }
 
     @Test
     void isStringEqualToShouldFailIfItIsNotAString() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").isStringEqualTo("1"))
-            .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <1>.");
+                .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <1>.");
     }
 
     @Test
     void isStringEqualToShouldFailIfItDiffers() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":\"2\"}").node("test").isStringEqualTo("1"))
-            .hasMessage("Different value found in node \"test\", expected: <\"1\"> but was: <\"2\">.");
+                .hasMessage("Different value found in node \"test\", expected: <\"1\"> but was: <\"2\">.");
     }
 
     @Test
@@ -756,7 +867,8 @@ void isStringEqualToShouldPass() {
     @Test
     void equalsShouldFailOnStringAndANumber() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":\"1\"}").node("test").isEqualTo("1"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test", expected: <1> but was: <"1">.
                 """);
@@ -765,7 +877,7 @@ void equalsShouldFailOnStringAndANumber() {
     @Test
     void isStringShouldFailOnNull() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":null}").node("test").isStringEqualTo("1"))
-            .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <null>.");
+                .hasMessage("Node \"test\" has invalid type, expected: <string> but was: <null>.");
     }
 
     @Test
@@ -780,7 +892,10 @@ void arrayOfLengthShouldPass() {
 
     @Test
     void arrayThatContainsShouldPass() {
-        assertThatJson("{\"test\":[{\"id\":36},{\"id\":37},{\"id\":38}]}").node("test").isArray().thatContains("{\"id\":37}");
+        assertThatJson("{\"test\":[{\"id\":36},{\"id\":37},{\"id\":38}]}")
+                .node("test")
+                .isArray()
+                .thatContains("{\"id\":37}");
     }
 
     @Test
@@ -790,20 +905,23 @@ void isObjectShouldPassOnObject() {
 
     @Test
     void isObjectShouldFailOnBoolean() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":true}}").node("test.a").isObject())
-            .hasMessage("Node \"test.a\" has invalid type, expected: <object> but was: <true>.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":true}}").node("test.a").isObject())
+                .hasMessage("Node \"test.a\" has invalid type, expected: <object> but was: <true>.");
     }
 
     @Test
     void isObjectShouldFailOnMissing() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":true}}").node("test.b").isObject())
-            .hasMessage("Different value found in node \"test.b\", expected: <object> but was: <missing>.");
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":true}}").node("test.b").isObject())
+                .hasMessage("Different value found in node \"test.b\", expected: <object> but was: <missing>.");
     }
 
     @Test
     void testNotEqualsToToArray() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":[1,2,3]}").node("test").isNotEqualTo(new int[]{1, 2, 3}))
-            .hasMessage("JSON is equal.");
+        assertThatThrownBy(
+                        () -> assertThatJson("{\"test\":[1,2,3]}").node("test").isNotEqualTo(new int[] {1, 2, 3}))
+                .hasMessage("JSON is equal.");
     }
 
     @Test
@@ -819,7 +937,8 @@ void testEqualsToNull() {
     @Test
     void testEqualsToNullFail() {
         assertThatThrownBy(() -> assertThatJson("{\"test\":1}").node("test").isEqualTo(null))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "test", expected: <null> but was: <1>.
                 """);
@@ -852,8 +971,10 @@ void testIssue3Original() {
 
     @Test
     void testNullAndAbsent() {
-        assertThatThrownBy(() -> assertThatJson("{\"test\":{\"a\":1, \"b\": null}}").isEqualTo("{\"test\":{\"a\":1}}"))
-            .hasMessage("""
+        assertThatThrownBy(() ->
+                        assertThatJson("{\"test\":{\"a\":1, \"b\": null}}").isEqualTo("{\"test\":{\"a\":1}}"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "test", extra: "test.b", expected: <{"a":1}> but was: <{"a":1,"b":null}>
                 """);
@@ -861,12 +982,16 @@ void testNullAndAbsent() {
 
     @Test
     void testTreatNullAsAbsent() {
-        assertThatJson("{\"test\":{\"a\":1, \"b\": null}}").when(TREATING_NULL_AS_ABSENT).isEqualTo("{\"test\":{\"a\":1}}");
+        assertThatJson("{\"test\":{\"a\":1, \"b\": null}}")
+                .when(TREATING_NULL_AS_ABSENT)
+                .isEqualTo("{\"test\":{\"a\":1}}");
     }
 
     @Test
     void shouldIgnoreExtraFields() {
-        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}").when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
+        assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
+                .when(IGNORING_EXTRA_FIELDS)
+                .isEqualTo("{\"test\":{\"b\":2}}");
     }
 
     @Test
@@ -881,8 +1006,11 @@ void shouldAcceptEscapedPathWithTwoDots() {
 
     @Test
     void shouldAcceptEscapedPathAndShowCorrectErrorMessage() {
-        assertThatThrownBy(() -> assertThatJson("{\"foo.bar\":\"boo\"}").node("foo\\.bar").isEqualTo("baz"))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThatJson("{\"foo.bar\":\"boo\"}")
+                        .node("foo\\.bar")
+                        .isEqualTo("baz"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "foo\\.bar", expected: <"baz"> but was: <"boo">.
                 """);
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonMatchersTest.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonMatchersTest.java
index 61c644518..557cb8f16 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonMatchersTest.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/AbstractJsonMatchersTest.java
@@ -15,13 +15,6 @@
  */
 package net.javacrumbs.jsonunit.test.base;
 
-import net.javacrumbs.jsonunit.ConfigurableJsonMatcher;
-import net.javacrumbs.jsonunit.JsonAssert;
-import org.hamcrest.Matcher;
-import org.hamcrest.StringDescription;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Test;
-
 import static java.math.BigDecimal.valueOf;
 import static java.util.Collections.singletonList;
 import static net.javacrumbs.jsonunit.JsonMatchers.jsonEquals;
@@ -51,6 +44,13 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import net.javacrumbs.jsonunit.ConfigurableJsonMatcher;
+import net.javacrumbs.jsonunit.JsonAssert;
+import org.hamcrest.Matcher;
+import org.hamcrest.StringDescription;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
 public abstract class AbstractJsonMatchersTest {
     @AfterEach
     void reset() {
@@ -79,7 +79,7 @@ void testJsonPartMatches() {
     @Test
     void jsonPartMatchesShouldReturnNiceException() {
         assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(2)))))
-            .hasMessage("""
+                .hasMessage("""
 
                 Expected: node "test" is <2>
                      but: was <1>""");
@@ -88,7 +88,8 @@ void jsonPartMatchesShouldReturnNiceException() {
     @Test
     void jsonPartMatchesShouldFailOnMissing() {
         assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonPartMatches("test2", is(valueOf(2)))))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: node "test2" is <2>
                      but: Node "test2" is missing.""");
@@ -97,7 +98,7 @@ void jsonPartMatchesShouldFailOnMissing() {
     @Test
     void shouldAddPathPrefixToPath() {
         assertThatThrownBy(() -> assertThat(jsonSource("{\"test\":1}", "$"), jsonPartMatches("test", is(valueOf(2)))))
-            .hasMessage("""
+                .hasMessage("""
 
                 Expected: node "$.test" is <2>
                      but: was <1>""");
@@ -110,8 +111,10 @@ void testJsonPartMatchesArray() {
 
     @Test
     void jsonPartMatchesShouldReturnNiceExceptionForArray() {
-        assertThatThrownBy(() -> assertThat("{\"test\":[1, 2, 3]}", jsonPartMatches("test", hasItems(valueOf(1), valueOf(2), valueOf(4)))))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThat(
+                        "{\"test\":[1, 2, 3]}", jsonPartMatches("test", hasItems(valueOf(1), valueOf(2), valueOf(4)))))
+                .hasMessage(
+                        """
 
                 Expected: node "test" (a collection containing <1> and a collection containing <2> and a collection containing <4>)
                      but: was <[1, 2, 3]>""");
@@ -119,8 +122,12 @@ void jsonPartMatchesShouldReturnNiceExceptionForArray() {
 
     @Test
     void ifMatcherDoesNotMatchReportDifference() {
-        assertThatThrownBy(() -> assertThat("{\"test\":-1}", jsonEquals("{\"test\": \"${json-unit.matches:positive}\"}").withMatcher("positive", greaterThan(valueOf(0)))))
-            .hasMessage("""
+        assertThatThrownBy(() -> assertThat(
+                        "{\"test\":-1}",
+                        jsonEquals("{\"test\": \"${json-unit.matches:positive}\"}")
+                                .withMatcher("positive", greaterThan(valueOf(0)))))
+                .hasMessage(
+                        """
 
                 Expected: {"test": "${json-unit.matches:positive}"}
                      but: JSON documents are different:
@@ -130,13 +137,16 @@ void ifMatcherDoesNotMatchReportDifference() {
 
     @Test
     void pathShouldBeIgnoredForDifferentValue() {
-        assertThat("{\"root\":{\"test\":1, \"ignored\": 2}}", jsonEquals("{\"root\":{\"test\":1, \"ignored\": 1}}").whenIgnoringPaths("root.ignored"));
-     }
+        assertThat(
+                "{\"root\":{\"test\":1, \"ignored\": 2}}",
+                jsonEquals("{\"root\":{\"test\":1, \"ignored\": 1}}").whenIgnoringPaths("root.ignored"));
+    }
 
     @Test
     void shouldNotFailOnEmptyInput() {
         assertThatThrownBy(() -> assertThat("", jsonEquals("{\"test\":1}")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: {"test":1}
                      but: JSON documents are different:
@@ -164,24 +174,29 @@ void testToleranceStatic() {
 
     @Test
     void testTolerance() {
-        assertThat("{\"test\":1.00001}", jsonEquals("{\"test\":1}").withTolerance(0.001).when(IGNORING_EXTRA_FIELDS));
+        assertThat(
+                "{\"test\":1.00001}",
+                jsonEquals("{\"test\":1}").withTolerance(0.001).when(IGNORING_EXTRA_FIELDS));
     }
 
     @Test
     void shouldIgnoreExtraFields() {
-        assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}", jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
+        assertThat(
+                "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
+                jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
     }
 
     @Test
     void hasItemShouldWork() {
-        //assertThat(asList("{\"test\":1}"), hasItem(jsonEquals("{\"test\":1}"))); //does not compile
+        // assertThat(asList("{\"test\":1}"), hasItem(jsonEquals("{\"test\":1}"))); //does not compile
         assertThat(singletonList("{\"test\":1}"), contains(jsonEquals("{\"test\":1}")));
     }
 
     @Test
     void testAssertDifferentTypeInt() {
         assertThatThrownBy(() -> assertThat("{\"test\":\"1\"}", jsonPartEquals("test", 1)))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: 1 in "test"
                      but: JSON documents are different:
@@ -201,11 +216,11 @@ void testGenericsIntAndString() {
         assertThat("{\"test\":1}", stringMatcher);
     }
 
-
     @Test
     void testDifferentValue() {
         assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonEquals("{\n\"test\": 2\n}")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: {
                 "test": 2
@@ -218,7 +233,8 @@ void testDifferentValue() {
     @Test
     void testDifferentStructure() {
         assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonEquals("{\n\"test2\": 2\n}")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: {
                 "test2": 2
@@ -231,8 +247,10 @@ void testDifferentStructure() {
     @Test
     void testDifferentPartValue() {
         RecordingDifferenceListener listener = new RecordingDifferenceListener();
-        assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonPartEquals("test", "2").withDifferenceListener(listener)))
-            .hasMessage("""
+        assertThatThrownBy(() ->
+                        assertThat("{\"test\":1}", jsonPartEquals("test", "2").withDifferenceListener(listener)))
+                .hasMessage(
+                        """
 
                 Expected: 2 in "test"
                      but: JSON documents are different:
@@ -240,13 +258,16 @@ void testDifferentPartValue() {
                 """);
 
         assertEquals(1, listener.getDifferenceList().size());
-        assertEquals("DIFFERENT Expected 2 in test got 1 in test", listener.getDifferenceList().get(0).toString());
+        assertEquals(
+                "DIFFERENT Expected 2 in test got 1 in test",
+                listener.getDifferenceList().get(0).toString());
     }
 
     @Test
     void testAbsent() {
         assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonNodeAbsent("test")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: Node "test" is absent.
                      but: Node "test" is "1".""");
@@ -255,7 +276,8 @@ void testAbsent() {
     @Test
     void testAbsentShouldAddPathToThePrefix() {
         assertThatThrownBy(() -> assertThat(jsonSource("{\"test\":1}", "$"), jsonNodeAbsent("test")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: Node "$.test" is absent.
                      but: Node "$.test" is "1".""");
@@ -269,17 +291,18 @@ void testAbsentOk() {
     @Test
     void testPresent() {
         assertThatThrownBy(() -> assertThat("{\"test\":1}", jsonNodePresent("test.a")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: Node "test.a" is present.
                      but: Node "test.a" is missing.""");
     }
 
-
     @Test
     void testPresentShouldAddPathToThePrefix() {
         assertThatThrownBy(() -> assertThat(jsonSource("{\"test\":1}", "$"), jsonNodePresent("test.a")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: Node "$.test.a" is present.
                      but: Node "$.test.a" is missing.""");
@@ -287,8 +310,10 @@ void testPresentShouldAddPathToThePrefix() {
 
     @Test
     void testPresentIfNullAndTreatingNullAsAbsent() {
-        assertThatThrownBy(() -> assertThat("{\"test\":null}", jsonNodePresent("test").when(TREATING_NULL_AS_ABSENT)))
-            .hasMessage("""
+        assertThatThrownBy(() ->
+                        assertThat("{\"test\":null}", jsonNodePresent("test").when(TREATING_NULL_AS_ABSENT)))
+                .hasMessage(
+                        """
 
                 Expected: Node "test" is present.
                      but: Node "test" is missing.""");
@@ -302,7 +327,8 @@ void testPresentOk() {
     @Test
     void testNullAndAbsent() {
         assertThatThrownBy(() -> assertThat("{\"test\":{\"a\":1, \"b\": null}}", jsonEquals("{\"test\":{\"a\":1}}")))
-            .hasMessage("""
+                .hasMessage(
+                        """
 
                 Expected: {"test":{"a":1}}
                      but: JSON documents are different:
@@ -312,7 +338,9 @@ void testNullAndAbsent() {
 
     @Test
     void shouldIgnoreValues() {
-        assertThat("{\"test\":{\"a\":3,\"b\":2,\"c\":1}}", jsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}").when(IGNORING_VALUES));
+        assertThat(
+                "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
+                jsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}").when(IGNORING_VALUES));
     }
 
     @Test
@@ -332,7 +360,10 @@ void jsonEqualsResourceShouldReturnReasonWhenDiffers() {
             assertThat("{\"test\":2}", jsonEquals(resource("test.json")));
             expectException();
         } catch (AssertionError e) {
-            assertThat(e.getMessage(), containsString("""
+            assertThat(
+                    e.getMessage(),
+                    containsString(
+                            """
 
                      but: JSON documents are different:
                 Different value found in node "test", expected <1> but was <2>.
@@ -362,11 +393,7 @@ void jsonEqualsResourceShouldReturnReasonWhenNullPassedAsParameter() {
 
     @Test
     void nullPointerExceptionTest() {
-        String message = "{"
-            + "     \"properties\":{"
-            + "         \"attr\":\"123\""
-            + "     }"
-            + "}";
+        String message = "{" + "     \"properties\":{" + "         \"attr\":\"123\"" + "     }" + "}";
         String path = "properties.another[0]";
         String expected = "VALUE";
         jsonPartEquals(path, expected).matches(message);
@@ -374,14 +401,18 @@ void nullPointerExceptionTest() {
 
     @Test
     void testSpecificPath() {
-        assertThat("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}",
-            jsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":4}}").when(path("test.c"), then(IGNORING_VALUES)));
+        assertThat(
+                "{\"test\":{\"a\":1,\"b\":2,\"c\":3}}",
+                jsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":4}}").when(path("test.c"), then(IGNORING_VALUES)));
     }
 
     @Test
     void testSpecificPathNot() {
-        assertThat("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}",
-            jsonEquals("{\"test\":{\"a\":5,\"b\":6,\"c\":3}}").when(IGNORING_VALUES).when(path("test.c"), thenNot(IGNORING_VALUES)));
+        assertThat(
+                "{\"test\":{\"a\":1,\"b\":2,\"c\":3}}",
+                jsonEquals("{\"test\":{\"a\":5,\"b\":6,\"c\":3}}")
+                        .when(IGNORING_VALUES)
+                        .when(path("test.c"), thenNot(IGNORING_VALUES)));
     }
 
     @Test
@@ -392,10 +423,12 @@ void matcherShouldDescribeTheOnlyMatch() {
         StringDescription description = new StringDescription();
         // Use different instance
         matcher.describeMismatch(actual, description);
-        assertEquals("""
+        assertEquals(
+                """
             JSON documents are different:
             Different value found in node "test", expected <1> but was <2>.
-            """, description.toString());
+            """,
+                description.toString());
     }
 
     private void expectException() {
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/JsonTestUtils.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/JsonTestUtils.java
index 653f63a30..6f793a0b4 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/JsonTestUtils.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/JsonTestUtils.java
@@ -17,13 +17,12 @@
 
 import com.google.gson.JsonParser;
 import com.squareup.moshi.Moshi;
-import org.json.JSONTokener;
-
-import javax.json.Json;
-import javax.json.JsonReader;
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.Map;
+import javax.json.Json;
+import javax.json.JsonReader;
+import org.json.JSONTokener;
 
 public class JsonTestUtils {
 
@@ -36,7 +35,7 @@ public static Object readByJackson2(String value) {
     }
 
     public static Object readByJohnzon(String value) {
-        try (JsonReader reader = Json.createReader(new StringReader(value))){
+        try (JsonReader reader = Json.createReader(new StringReader(value))) {
             return reader.read();
         }
     }
@@ -46,8 +45,8 @@ public static Object readByGson(String value) {
     }
 
     public static Object readByJsonOrg(String value) {
-            return new JSONTokener(value).nextValue();
-        }
+        return new JSONTokener(value).nextValue();
+    }
 
     public static Object readByMoshi(String value) {
         Moshi moshi = new Moshi.Builder().build();
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RecordingDifferenceListener.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RecordingDifferenceListener.java
index 8b70f7774..f97551483 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RecordingDifferenceListener.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RecordingDifferenceListener.java
@@ -15,13 +15,12 @@
  */
 package net.javacrumbs.jsonunit.test.base;
 
+import java.util.ArrayList;
+import java.util.List;
 import net.javacrumbs.jsonunit.core.listener.Difference;
 import net.javacrumbs.jsonunit.core.listener.DifferenceContext;
 import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class RecordingDifferenceListener implements DifferenceListener {
     private final List<Difference> differenceList = new ArrayList<>();
 
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RegexBuilder.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RegexBuilder.java
index 45a581c2f..5827867fd 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RegexBuilder.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/RegexBuilder.java
@@ -23,5 +23,4 @@ RegexBuilder exp(String regex) {
     public String toString() {
         return expression + "$\"";
     }
-
 }
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2Bean.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2Bean.java
index 0eec2bbc1..651262a0a 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2Bean.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2Bean.java
@@ -18,7 +18,7 @@
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.annotation.JsonTypeName;
 
-@JsonTypeInfo(use= JsonTypeInfo.Id.NAME, include= JsonTypeInfo.As.WRAPPER_OBJECT)
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
 @JsonTypeName("bean")
 public class Jackson2Bean {
     private final String property;
diff --git a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2IgnorePropertyBean.java b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2IgnorePropertyBean.java
index f026aec14..c8d41862a 100644
--- a/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2IgnorePropertyBean.java
+++ b/tests/test-base/src/main/java/net/javacrumbs/jsonunit/test/base/beans/Jackson2IgnorePropertyBean.java
@@ -15,7 +15,6 @@
  */
 package net.javacrumbs.jsonunit.test.base.beans;
 
-
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
 public class Jackson2IgnorePropertyBean {
diff --git a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllAssertJTest.java b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllAssertJTest.java
index 284fd3b04..23a7de673 100644
--- a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllAssertJTest.java
+++ b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllAssertJTest.java
@@ -15,6 +15,10 @@
  */
 package net.javacrumbs.jsonunit.test.all;
 
+import static net.javacrumbs.jsonunit.JsonMatchers.jsonEquals;
+import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
+import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJackson2;
+
 import net.javacrumbs.jsonunit.ConfigurableJsonMatcher;
 import net.javacrumbs.jsonunit.core.ParametrizedMatcher;
 import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
@@ -22,10 +26,6 @@
 import org.hamcrest.Description;
 import org.junit.jupiter.api.Test;
 
-import static net.javacrumbs.jsonunit.JsonMatchers.jsonEquals;
-import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
-import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJackson2;
-
 public class AllAssertJTest extends AbstractAssertJTest {
     @Override
     protected Object readValue(String value) {
@@ -33,46 +33,44 @@ protected Object readValue(String value) {
     }
 
     @Test
-        void embeddedJsonShouldBeParsed() {
-            String actual = "{" +
-                "\"response\": {" +
-                "\"body\": \"{'message':'Success','time-sent':'2018-12-10T14:49:11.537Z[GMT]'}\"" +
-                "}" +
-                "}";
+    void embeddedJsonShouldBeParsed() {
+        String actual = "{" + "\"response\": {"
+                + "\"body\": \"{'message':'Success','time-sent':'2018-12-10T14:49:11.537Z[GMT]'}\""
+                + "}"
+                + "}";
 
-            String expected = "{" +
-                "\"response\": {" +
-                "\"body\": \"${json-unit.matches:embeddedJson}{'message':'Success','time-sent':'${json-unit.ignore}'}\"" +
-                "}" +
-                "}";
+        String expected = "{" + "\"response\": {"
+                + "\"body\": \"${json-unit.matches:embeddedJson}{'message':'Success','time-sent':'${json-unit.ignore}'}\""
+                + "}"
+                + "}";
 
-            assertThatJson(actual).withConfiguration(c->c.withMatcher("embeddedJson", new EmbeddedJsonMatcher())).isEqualTo(expected);
-        }
-
-
-        static private class EmbeddedJsonMatcher extends BaseMatcher<Object> implements ParametrizedMatcher {
-            private ConfigurableJsonMatcher<Object> embeddedMatcher;
+        assertThatJson(actual)
+                .withConfiguration(c -> c.withMatcher("embeddedJson", new EmbeddedJsonMatcher()))
+                .isEqualTo(expected);
+    }
 
+    private static class EmbeddedJsonMatcher extends BaseMatcher<Object> implements ParametrizedMatcher {
+        private ConfigurableJsonMatcher<Object> embeddedMatcher;
 
-            @Override
-            public void setParameter(String parameter) {
-                embeddedMatcher = jsonEquals(parameter);
-            }
+        @Override
+        public void setParameter(String parameter) {
+            embeddedMatcher = jsonEquals(parameter);
+        }
 
-            @Override
-            public boolean matches(Object item) {
-                // leniently parse
-                return embeddedMatcher.matches(new org.json.JSONObject((String)item));
-            }
+        @Override
+        public boolean matches(Object item) {
+            // leniently parse
+            return embeddedMatcher.matches(new org.json.JSONObject((String) item));
+        }
 
-            @Override
-            public void describeTo(Description description) {
-                embeddedMatcher.describeTo(description);
-            }
+        @Override
+        public void describeTo(Description description) {
+            embeddedMatcher.describeTo(description);
+        }
 
-            @Override
-            public void describeMismatch(Object item, Description description) {
-                embeddedMatcher.describeMismatch(item, description);
-            }
+        @Override
+        public void describeMismatch(Object item, Description description) {
+            embeddedMatcher.describeMismatch(item, description);
         }
+    }
 }
diff --git a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonAssertTest.java b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonAssertTest.java
index c7506922b..d43fc806f 100644
--- a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonAssertTest.java
+++ b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonAssertTest.java
@@ -15,13 +15,6 @@
  */
 package net.javacrumbs.jsonunit.test.all;
 
-import net.javacrumbs.jsonunit.JsonAssert;
-import net.javacrumbs.jsonunit.test.base.AbstractJsonAssertTest;
-import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
-import net.javacrumbs.jsonunit.test.base.beans.Jackson2Bean;
-import net.javacrumbs.jsonunit.test.base.beans.Jackson2IgnorePropertyBean;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
 import static net.javacrumbs.jsonunit.JsonAssert.when;
 import static net.javacrumbs.jsonunit.core.Option.IGNORING_VALUES;
@@ -30,6 +23,13 @@
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJsonOrg;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import net.javacrumbs.jsonunit.JsonAssert;
+import net.javacrumbs.jsonunit.test.base.AbstractJsonAssertTest;
+import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
+import net.javacrumbs.jsonunit.test.base.beans.Jackson2Bean;
+import net.javacrumbs.jsonunit.test.base.beans.Jackson2IgnorePropertyBean;
+import org.junit.jupiter.api.Test;
+
 class AllJsonAssertTest extends AbstractJsonAssertTest {
 
     @Test
@@ -60,25 +60,29 @@ void testEqualsNodeIgnore() {
     @Test
     void testEqualsNodeFailJackson1() {
         assertThatThrownBy(() -> assertJsonEquals(readByJackson2("{\"test\":1}"), "{\"test\": 2}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void testEqualsNodeFailGson() {
         assertThatThrownBy(() -> assertJsonEquals(readByGson("{\"test\":1}"), "{\"test\": 2}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void testEqualsNodeFailJsonOrg() {
         assertThatThrownBy(() -> assertJsonEquals(readByJsonOrg("{\"test\":1}"), "{\"test\": 2}"))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void testEqualsNodeFailJsonOrgArray() {
         assertThatThrownBy(() -> assertJsonEquals(readByJsonOrg("[1, 2]"), readByJsonOrg("[1, 2, 3]")))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "" has different length, expected: <2> but was: <3>.
                 Array "" has different content. Extra values: [3], expected: <[1,2]> but was: <[1,2,3]>
@@ -88,7 +92,8 @@ void testEqualsNodeFailJsonOrgArray() {
     @Test
     void assertEqualsDifferentTypesFailsOnDifferentTypes() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": 3}", "{\"test\": {\"inner\": 5}}", when(IGNORING_VALUES)))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <3> but was: <{\"inner\":5}>.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <3> but was: <{\"inner\":5}>.\n");
     }
 
     @Test
@@ -99,13 +104,15 @@ void assertEqualsDifferentTypesPassesIfOnlyValuesDiffer() {
     @Test
     void testEqualsNodeStringFail() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":\"a\"}", readByJackson2("{\"test\": \"b\"}")))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"test\", expected: <\"a\"> but was: <\"b\">.\n");
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"test\", expected: <\"a\"> but was: <\"b\">.\n");
     }
 
     @Test
     void testEqualsExtraNodeStringFail() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\":\"a\"}", "{\"test\": \"a\", \"test2\": \"aa\"}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", extra: "test2", expected: <{"test":"a"}> but was: <{"test":"a","test2":"aa"}>
                 """);
@@ -114,7 +121,8 @@ void testEqualsExtraNodeStringFail() {
     @Test
     void testEqualsMissedNodeStringFail() {
         assertThatThrownBy(() -> assertJsonEquals("{\"test\": \"a\", \"test2\": \"aa\"}", "{\"test\":\"a\"}"))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "test2", expected: <{"test":"a","test2":"aa"}> but was: <{"test":"a"}>
                 """);
@@ -133,37 +141,33 @@ void shouldSerializeBasedOnMethodAnnotation() {
     @Test
     void dotInPathFailure() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "{\"root\":{\"test\":1, \".ignored\": 1}}",
-                "{\"root\":{\"test\":1, \".ignored\": 2}}"
-        ))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"root..ignored\", expected: <1> but was: <2>.\n");
+                        "{\"root\":{\"test\":1, \".ignored\": 1}}", "{\"root\":{\"test\":1, \".ignored\": 2}}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"root..ignored\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void dotInPathMiddleFailure() {
         assertThatThrownBy(() -> assertJsonEquals(
-            "{\"root\":{\"test\":1, \"igno.red\": 1}}",
-            "{\"root\":{\"test\":1, \"igno.red\": 2}}"
-        ))
-            .hasMessage("JSON documents are different:\nDifferent value found in node \"root.igno.red\", expected: <1> but was: <2>.\n");
+                        "{\"root\":{\"test\":1, \"igno.red\": 1}}", "{\"root\":{\"test\":1, \"igno.red\": 2}}"))
+                .hasMessage(
+                        "JSON documents are different:\nDifferent value found in node \"root.igno.red\", expected: <1> but was: <2>.\n");
     }
 
     @Test
     void dotInPath() {
         assertJsonEquals(
-        "{\"root\":{\"test\":1, \".ignored\": 1}}",
-            "{\"root\":{\"test\":1, \".ignored\": 2}}",
-        JsonAssert.whenIgnoringPaths("root..ignored")
-        );
+                "{\"root\":{\"test\":1, \".ignored\": 1}}",
+                "{\"root\":{\"test\":1, \".ignored\": 2}}",
+                JsonAssert.whenIgnoringPaths("root..ignored"));
     }
 
     @Test
     void dotInPathMiddle() {
         assertJsonEquals(
-        "{\"root\":{\"test\":1, \"igno.red\": 1}}",
-            "{\"root\":{\"test\":1, \"igno.red\": 2}}",
-        JsonAssert.whenIgnoringPaths("root.igno.red")
-        );
+                "{\"root\":{\"test\":1, \"igno.red\": 1}}",
+                "{\"root\":{\"test\":1, \"igno.red\": 2}}",
+                JsonAssert.whenIgnoringPaths("root.igno.red"));
     }
 
     @Override
diff --git a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonFluentAssertTest.java b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonFluentAssertTest.java
index 37c901468..d0cc7aa84 100644
--- a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonFluentAssertTest.java
+++ b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonFluentAssertTest.java
@@ -15,15 +15,15 @@
  */
 package net.javacrumbs.jsonunit.test.all;
 
-import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
-import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByGson;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJackson2;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJsonOrg;
 
+import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
+import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
+import org.junit.jupiter.api.Test;
+
 public class AllJsonFluentAssertTest extends AbstractJsonFluentAssertTest {
     @Test
     void testMixedGsonAndJackson() {
diff --git a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonMatchersTest.java b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonMatchersTest.java
index 323bc98a8..d23e0db86 100644
--- a/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonMatchersTest.java
+++ b/tests/test-base/src/test/java/net/javacrumbs/jsonunit/test/all/AllJsonMatchersTest.java
@@ -15,16 +15,16 @@
  */
 package net.javacrumbs.jsonunit.test.all;
 
-import net.javacrumbs.jsonunit.test.base.AbstractJsonMatchersTest;
-import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.JsonMatchers.jsonEquals;
 import static net.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJackson2;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJsonOrg;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+import net.javacrumbs.jsonunit.test.base.AbstractJsonMatchersTest;
+import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
+import org.junit.jupiter.api.Test;
+
 class AllJsonMatchersTest extends AbstractJsonMatchersTest {
     @Test
     void testJsonNodeJsonOrg() {
@@ -38,7 +38,9 @@ void testJsonNodeJackson2() {
 
     @Test
     void shouldCompareJSONArrays() {
-        assertThat(readByJsonOrg("[{\"a\":1}, {\"a\":2}, {\"a\":2}]"), jsonEquals(readByJsonOrg("[{\"a\":1}, {\"a\":2}, {\"a\":2}]")));
+        assertThat(
+                readByJsonOrg("[{\"a\":1}, {\"a\":2}, {\"a\":2}]"),
+                jsonEquals(readByJsonOrg("[{\"a\":1}, {\"a\":2}, {\"a\":2}]")));
     }
 
     @Test
@@ -53,6 +55,6 @@ void testEqualsUnicodeResource() {
 
     @Override
     protected Object readValue(String value) {
-            return JsonTestUtils.readByJackson2(value);
-        }
+        return JsonTestUtils.readByJackson2(value);
+    }
 }
diff --git a/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonAssertJTest.java b/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonAssertJTest.java
index 520542a03..1252b448c 100644
--- a/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonAssertJTest.java
+++ b/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonAssertJTest.java
@@ -18,7 +18,7 @@
 import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
 import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
 
-public class GsonAssertJTest  extends AbstractAssertJTest {
+public class GsonAssertJTest extends AbstractAssertJTest {
 
     @Override
     protected Object readValue(String value) {
diff --git a/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonAssertTest.java b/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonAssertTest.java
index b8661f291..54382409a 100644
--- a/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonAssertTest.java
+++ b/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonAssertTest.java
@@ -33,7 +33,6 @@ public void shouldFailIfQuotationMarksMissingOnActualKeys() {
         // GSON is by default lenient
     }
 
-
     @Test
     @Override
     @Disabled
diff --git a/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonFluentAssertTest.java b/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonFluentAssertTest.java
index d8ef96d22..7f60d6aee 100644
--- a/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonFluentAssertTest.java
+++ b/tests/test-gson/src/test/java/net/javacrumbs/jsonunit/test/gson/GsonJsonFluentAssertTest.java
@@ -15,13 +15,13 @@
  */
 package net.javacrumbs.jsonunit.test.gson;
 
+import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
+
 import com.google.gson.JsonObject;
 import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
 import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
 import org.junit.jupiter.api.Test;
 
-import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
-
 public class GsonJsonFluentAssertTest extends AbstractJsonFluentAssertTest {
     @Override
     protected Object readValue(String value) {
diff --git a/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Jackson2ConfigTest.java b/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Jackson2ConfigTest.java
index b92bf5aac..d9af49a1a 100644
--- a/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Jackson2ConfigTest.java
+++ b/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Jackson2ConfigTest.java
@@ -15,13 +15,12 @@
  */
 package net.javacrumbs.jsonunit.test.jackson2config;
 
-import org.junit.jupiter.api.Test;
-
-import java.time.Instant;
-
 import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
 import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
 
+import java.time.Instant;
+import org.junit.jupiter.api.Test;
+
 class Jackson2ConfigTest {
 
     @Test
diff --git a/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Java8ObjectMapperProvider.java b/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Java8ObjectMapperProvider.java
index 1f2357baa..5defc7977 100644
--- a/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Java8ObjectMapperProvider.java
+++ b/tests/test-jackson2-config/src/test/java/net/javacrumbs/jsonunit/test/jackson2config/Java8ObjectMapperProvider.java
@@ -27,7 +27,6 @@ public class Java8ObjectMapperProvider implements Jackson2ObjectMapperProvider {
 
     private final ObjectMapper lenientMapper;
 
-
     public Java8ObjectMapperProvider() {
         mapper = new ObjectMapper().registerModule(new JavaTimeModule());
         mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
diff --git a/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2AssertJTest.java b/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2AssertJTest.java
index 9f00c69ef..72997fce0 100644
--- a/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2AssertJTest.java
+++ b/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2AssertJTest.java
@@ -15,29 +15,25 @@
  */
 package net.javacrumbs.jsonunit.test.jackson2;
 
-import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
 import static net.javacrumbs.jsonunit.assertj.JsonAssertions.json;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJackson2;
 
-public class Jackson2AssertJTest extends AbstractAssertJTest {
+import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
+import org.junit.jupiter.api.Test;
 
+public class Jackson2AssertJTest extends AbstractAssertJTest {
 
     @Test
     void arrayContainsWithObjects() {
         assertThatJson("{\"a\":[{\"b\": 1}, {\"c\": 1}]}")
-            .inPath("$.a")
-            .isArray()
-            .containsExactlyInAnyOrder(
-                json(readValue("{\"c\": 1}")),
-                json(readValue("{\"b\": 1}"))
-            );
+                .inPath("$.a")
+                .isArray()
+                .containsExactlyInAnyOrder(json(readValue("{\"c\": 1}")), json(readValue("{\"b\": 1}")));
     }
 
     @Override
     protected Object readValue(String value) {
-            return readByJackson2(value);
-        }
+        return readByJackson2(value);
+    }
 }
diff --git a/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2FluentAssertTest.java b/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2FluentAssertTest.java
index f4da468ef..a56ba4c97 100644
--- a/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2FluentAssertTest.java
+++ b/tests/test-jackson2/src/test/java/net/javacrumbs/jsonunit/test/jackson2/Jackson2FluentAssertTest.java
@@ -15,12 +15,12 @@
  */
 package net.javacrumbs.jsonunit.test.jackson2;
 
+import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
+
 import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
 import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
 import org.junit.jupiter.api.Test;
 
-import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
-
 public class Jackson2FluentAssertTest extends AbstractJsonFluentAssertTest {
     @Override
     protected Object readValue(String value) {
diff --git a/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonAssertJTest.java b/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonAssertJTest.java
index 23d0dfecf..92e39ceb0 100644
--- a/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonAssertJTest.java
+++ b/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonAssertJTest.java
@@ -24,8 +24,8 @@ public class JohnzonAssertJTest extends AbstractAssertJTest {
 
     @Override
     protected Object readValue(String value) {
-            return JsonTestUtils.readByJohnzon(value);
-        }
+        return JsonTestUtils.readByJohnzon(value);
+    }
 
     @Test
     @Override
@@ -43,7 +43,5 @@ protected void demo() {
 
     @Override
     @Disabled
-    protected void shouldAssertLenient() {
-
-    }
+    protected void shouldAssertLenient() {}
 }
diff --git a/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonAssertTest.java b/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonAssertTest.java
index a99c505d9..26907e0b7 100644
--- a/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonAssertTest.java
+++ b/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonAssertTest.java
@@ -33,7 +33,6 @@ public void shouldFailIfQuotationMarksMissingOnActualKeys() {
         // GSON is by default lenient
     }
 
-
     @Test
     @Override
     @Disabled
diff --git a/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonFluentAssertTest.java b/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonFluentAssertTest.java
index c5fdfd253..d784fa284 100644
--- a/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonFluentAssertTest.java
+++ b/tests/test-johnzon/src/test/java/net/javacrumbs/jsonunit/test/johnzon/JohnzonJsonFluentAssertTest.java
@@ -15,16 +15,15 @@
  */
 package net.javacrumbs.jsonunit.test.johnzon;
 
-import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
-import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
+import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
 
 import javax.json.Json;
 import javax.json.JsonObject;
 import javax.json.JsonValue;
-
-import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
+import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
+import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 public class JohnzonJsonFluentAssertTest extends AbstractJsonFluentAssertTest {
     @Override
@@ -34,15 +33,13 @@ protected Object readValue(String value) {
 
     @Test
     void shouldNotChangeObject() {
-        JsonObject json = Json.createObjectBuilder()
-            .add("test", JsonValue.NULL)
-            .build();
+        JsonObject json = Json.createObjectBuilder().add("test", JsonValue.NULL).build();
         assertThatJson(json).isEqualTo("{\"test\":null}");
     }
 
     @Override
     @Disabled
     protected void shouldAllowUnquotedKeysAndCommentInExpectedValue() {
-        //not supported
+        // not supported
     }
 }
diff --git a/tests/test-json-path/src/test/java/net/javacrumbs/jsonunit/test/jsonpath/JsonPathTest.java b/tests/test-json-path/src/test/java/net/javacrumbs/jsonunit/test/jsonpath/JsonPathTest.java
index 5b5f43a35..f92a7907c 100644
--- a/tests/test-json-path/src/test/java/net/javacrumbs/jsonunit/test/jsonpath/JsonPathTest.java
+++ b/tests/test-json-path/src/test/java/net/javacrumbs/jsonunit/test/jsonpath/JsonPathTest.java
@@ -15,34 +15,33 @@
  */
 package net.javacrumbs.jsonunit.test.jsonpath;
 
-import net.javacrumbs.jsonunit.core.Option;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
 import static net.javacrumbs.jsonunit.jsonpath.JsonPathAdapter.inPath;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import net.javacrumbs.jsonunit.core.Option;
+import org.junit.jupiter.api.Test;
+
 class JsonPathTest {
     @Test
     void shouldBeAbleToUseSimpleValues() {
         assertThatJson(inPath(json, "$.store.book[*].author"))
-            .isEqualTo("['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'J. R. R. Tolkien']");
-
+                .isEqualTo("['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'J. R. R. Tolkien']");
     }
 
     @Test
     void shouldBeAbleToUseSimpleValuesAndIgnoreArrayOrder() {
         assertThatJson(inPath(json, "$.store.book[*].author"))
-            .when(Option.IGNORING_ARRAY_ORDER)
-            .isEqualTo("['J. R. R. Tolkien', 'Nigel Rees', 'Evelyn Waugh', 'Herman Melville']");
-
+                .when(Option.IGNORING_ARRAY_ORDER)
+                .isEqualTo("['J. R. R. Tolkien', 'Nigel Rees', 'Evelyn Waugh', 'Herman Melville']");
     }
 
     @Test
     void shouldBeAbleToUseSimpleValuesFailure() {
         assertThatThrownBy(() -> assertThatJson(inPath(json, "$.store.book[*].author"))
-            .isEqualTo("['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'Arthur C. Clark']"))
-            .hasMessage("""
+                        .isEqualTo("['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'Arthur C. Clark']"))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "$.store.book[*].author[3]", expected: <"Arthur C. Clark"> but was: <"J. R. R. Tolkien">.
                 """);
@@ -50,9 +49,10 @@ void shouldBeAbleToUseSimpleValuesFailure() {
 
     @Test
     void shouldBeAbleToUseObjects() {
-        assertThatThrownBy(() -> assertThatJson(inPath(json, "$.store.book[0]"))
-            .isEqualTo(
-                """
+        assertThatThrownBy(
+                        () -> assertThatJson(inPath(json, "$.store.book[0]"))
+                                .isEqualTo(
+                                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
@@ -60,7 +60,8 @@ void shouldBeAbleToUseObjects() {
                                     "price": 8.96
                                 }\
                     """))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different value found in node "$.store.book[0].price", expected: <8.96> but was: <8.95>.
                 """);
@@ -69,9 +70,9 @@ void shouldBeAbleToUseObjects() {
     @Test
     void shouldIgnorePath() {
         assertThatJson(inPath(json, "$.store.book[0]"))
-            .whenIgnoringPaths("$.store.book[*].price")
-            .isEqualTo(
-                """
+                .whenIgnoringPaths("$.store.book[*].price")
+                .isEqualTo(
+                        """
                                 {
                                     "category": "reference",
                                     "author": "Nigel Rees",
@@ -81,8 +82,8 @@ void shouldIgnorePath() {
                     """);
     }
 
-
-    private static final String json = """
+    private static final String json =
+            """
         {
             "store": {
                 "book": [
diff --git a/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgAssertJTest.java b/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgAssertJTest.java
index e6d11de84..ce0a944ef 100644
--- a/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgAssertJTest.java
+++ b/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgAssertJTest.java
@@ -15,12 +15,12 @@
  */
 package net.javacrumbs.jsonunit.test.jsonorg;
 
-import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJsonOrg;
 
+import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
+import org.junit.jupiter.api.Test;
+
 public class JsonOrgAssertJTest extends AbstractAssertJTest {
 
     @Override
diff --git a/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonAssertTest.java b/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonAssertTest.java
index c51585f40..fd328f060 100644
--- a/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonAssertTest.java
+++ b/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonAssertTest.java
@@ -15,15 +15,15 @@
  */
 package net.javacrumbs.jsonunit.test.jsonorg;
 
+import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
+import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJsonOrg;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
 import net.javacrumbs.jsonunit.test.base.AbstractJsonAssertTest;
 import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
-import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
-import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByJsonOrg;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
 public class JsonOrgJsonAssertTest extends AbstractJsonAssertTest {
     @Override
     protected Object readValue(String value) {
@@ -45,7 +45,8 @@ public void shouldFailIfQuotationMarksMissingOnActualKeys() {
     @Test
     public void testEqualsNodeFailJsonOrgArray() {
         assertThatThrownBy(() -> assertJsonEquals(readByJsonOrg("[1, 2]"), readByJsonOrg("[1, 2, 3]")))
-            .hasMessage("""
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Array "" has different length, expected: <2> but was: <3>.
                 Array "" has different content. Extra values: [3], expected: <[1,2]> but was: <[1,2,3]>
@@ -58,5 +59,4 @@ public void testEqualsNodeFailJsonOrgArray() {
     public void testBinary() {
         // no support for binary
     }
-
 }
diff --git a/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonFluentAssertTest.java b/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonFluentAssertTest.java
index f88a48fca..bcc21a89d 100644
--- a/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonFluentAssertTest.java
+++ b/tests/test-jsonorg/src/test/java/net/javacrumbs/jsonunit/test/jsonorg/JsonOrgJsonFluentAssertTest.java
@@ -15,12 +15,12 @@
  */
 package net.javacrumbs.jsonunit.test.jsonorg;
 
+import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
+
 import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
 import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
 import org.junit.jupiter.api.Test;
 
-import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
-
 public class JsonOrgJsonFluentAssertTest extends AbstractJsonFluentAssertTest {
     @Override
     protected Object readValue(String value) {
diff --git a/tests/test-junit4/src/test/java/net/javacrumbs/jsonunit/test/junit4/JUnit4Test.java b/tests/test-junit4/src/test/java/net/javacrumbs/jsonunit/test/junit4/JUnit4Test.java
index 063f4f2f2..8fa669562 100644
--- a/tests/test-junit4/src/test/java/net/javacrumbs/jsonunit/test/junit4/JUnit4Test.java
+++ b/tests/test-junit4/src/test/java/net/javacrumbs/jsonunit/test/junit4/JUnit4Test.java
@@ -1,16 +1,17 @@
 package net.javacrumbs.jsonunit.test.junit4;
 
-
-import org.junit.Test;
-
 import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import org.junit.Test;
+
 public class JUnit4Test {
 
     @Test
     public void testComplexErrors() {
-        assertThatThrownBy(() -> assertJsonEquals("""
+        assertThatThrownBy(
+                        () -> assertJsonEquals(
+                                """
                 {
                    "test":[
                       1,
@@ -29,7 +30,7 @@ public void testComplexErrors() {
                    "root2":false,
                    "root3":1
                 }""",
-            """
+                                """
                 {
                    "test":[
                       5,
@@ -49,9 +50,9 @@ public void testComplexErrors() {
                       }
                    ],
                    "root4":"bar"
-                }"""
-        ))
-            .hasMessage("""
+                }"""))
+                .hasMessage(
+                        """
                 JSON documents are different:
                 Different keys found in node "", missing: "root2","root3", extra: "root4", expected: <{"root2":false,"root3":1,"test":[1, 2, {"child":{"value1":1,"value2":true,"value3":"test","value4":{"leaf":5}}}]}> but was: <{"root4":"bar","test":[5, false, {"child":{"value1":5,"value2":"true","value3":"test","value4":{"leaf2":5}},"child2":{}}]}>
                 Different value found in node "test[0]", expected: <1> but was: <5>.
@@ -61,7 +62,5 @@ public void testComplexErrors() {
                 Different value found in node "test[2].child.value2", expected: <true> but was: <"true">.
                 Different keys found in node "test[2].child.value4", missing: "test[2].child.value4.leaf", extra: "test[2].child.value4.leaf2", expected: <{"leaf":5}> but was: <{"leaf2":5}>
                 """);
-
     }
-
 }
diff --git a/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiAssertJTest.java b/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiAssertJTest.java
index 376e1579d..887eef809 100644
--- a/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiAssertJTest.java
+++ b/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiAssertJTest.java
@@ -15,13 +15,13 @@
  */
 package net.javacrumbs.jsonunit.test.moshi;
 
-import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
 import static net.javacrumbs.jsonunit.test.base.JsonTestUtils.readByMoshi;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import net.javacrumbs.jsonunit.test.base.AbstractAssertJTest;
+import org.junit.jupiter.api.Test;
+
 public class MoshiAssertJTest extends AbstractAssertJTest {
 
     @Override
@@ -32,7 +32,7 @@ protected Object readValue(String value) {
     @Test
     void shouldAssertInteger() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":1}").node("a").isIntegralNumber())
-            .isInstanceOf(UnsupportedOperationException.class);
+                .isInstanceOf(UnsupportedOperationException.class);
     }
 
     @Test
@@ -44,7 +44,7 @@ protected void shouldAssert1e0() {
     @Test
     void shouldAssertIntegerFailure() {
         assertThatThrownBy(() -> assertThatJson("{\"a\":1.0}").node("a").isIntegralNumber())
-            .isInstanceOf(UnsupportedOperationException.class);
+                .isInstanceOf(UnsupportedOperationException.class);
     }
 
     @Test
diff --git a/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiFluentAssertTest.java b/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiFluentAssertTest.java
index 010ced133..ccda6fe61 100644
--- a/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiFluentAssertTest.java
+++ b/tests/test-moshi/src/test/java/net/javacrumbs/jsonunit/test/moshi/MoshiFluentAssertTest.java
@@ -15,12 +15,12 @@
  */
 package net.javacrumbs.jsonunit.test.moshi;
 
+import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
+
 import net.javacrumbs.jsonunit.test.base.AbstractJsonFluentAssertTest;
 import net.javacrumbs.jsonunit.test.base.JsonTestUtils;
 import org.junit.jupiter.api.Test;
 
-import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
-
 public class MoshiFluentAssertTest extends AbstractJsonFluentAssertTest {
     @Override
     protected Object readValue(String value) {
diff --git a/tests/test-no-hamcrest/src/test/java/net/javacrumbs/jsonunit/test/nohamcrest/NoHamcrestTest.java b/tests/test-no-hamcrest/src/test/java/net/javacrumbs/jsonunit/test/nohamcrest/NoHamcrestTest.java
index d019c821a..1a029b7de 100644
--- a/tests/test-no-hamcrest/src/test/java/net/javacrumbs/jsonunit/test/nohamcrest/NoHamcrestTest.java
+++ b/tests/test-no-hamcrest/src/test/java/net/javacrumbs/jsonunit/test/nohamcrest/NoHamcrestTest.java
@@ -15,11 +15,11 @@
  */
 package net.javacrumbs.jsonunit.test.nohamcrest;
 
-import org.junit.jupiter.api.Test;
-
 import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
 
-class NoHamcrestTest  {
+import org.junit.jupiter.api.Test;
+
+class NoHamcrestTest {
 
     @Test
     void comparisonShouldWork() {