diff --git a/README.md b/README.md
index e79ca47..e0c718b 100644
--- a/README.md
+++ b/README.md
@@ -1,131 +1,274 @@
 # Java json-diff
 
-A customizable lib to perform a json-diff
+A customizable library to perform JSON comparisons with detailed diff output.
 
-## Why Use json-diff library
+## Why Use json-diff?
 
-The goal of this library is to provide a readable diff between two json file.
+This library provides:
 
-In addition to the differential, a similarity score is calculated.
-This score can be used to compare several json with each other and find the two most similar.
-
-The way to compare json is completely customisable.
-
-2 way to display diff are provided by default (patch file, text file). And you can easily create your own formatter.
+- **Readable diffs** between two JSON documents
+- **Similarity scoring** (0-100) to compare multiple JSON documents and find the most similar ones
+- **Fully customizable** comparison modes (strict, lenient, or mixed) with easy-to-create custom matchers
+- **Multiple output formats** (patch file, text) with the ability to create custom formatters
 
 ## Installation
 
-maven: 
+**Maven:**
 ```xml
 <dependency>
     <groupId>io.github.deblockt</groupId>
     <artifactId>json-diff</artifactId>
-    <version>1.1.0</version>
+    <version>2.0.0</version>
 </dependency>
 ```
 
-gradle:
+**Gradle:**
 ```gradle
-implementation 'io.github.deblockt:json-diff:1.1.0'
+implementation 'io.github.deblockt:json-diff:2.0.0'
 ```
 
-## Usage
+> **Note:** Version 2.0.0 requires Java 21+ and uses Jackson 3.x
+
+## Quick Start
 
-example:
 ```java
-final var expectedJson = "{\"additionalProperty\":\"a\", \"foo\": \"bar\", \"bar\": \"bar\", \"numberMatch\": 10.0, \"numberUnmatched\": 10.01, \"arrayMatch\": [{\"b\":\"a\"}], \"arrayUnmatched\": [{\"b\":\"a\"}]}";
-final var receivedJson = "{\"foo\": \"foo\", \"bar\": \"bar\", \"numberMatch\": 10, \"numberUnmatched\": 10.02, \"arrayMatch\": [{\"b\":\"a\"}], \"arrayUnmatched\": {\"b\":\"b\"}}";
+final var expectedJson = "{\"name\": \"John\", \"age\": 30, \"city\": \"Paris\"}";
+final var receivedJson = "{\"name\": \"Jane\", \"age\": 30, \"country\": \"France\"}";
 
-// define your matcher
-// CompositeJsonMatcher use other matcher to perform matching on objects, list or primitive
+// Define your matcher
 final var jsonMatcher = new CompositeJsonMatcher(
-    new LenientJsonArrayPartialMatcher(), // comparing array using lenient mode (ignore array order and extra items)
-    new LenientJsonObjectPartialMatcher(), // comparing object using lenient mode (ignoring extra properties)
-    new LenientNumberPrimitivePartialMatcher(new StrictPrimitivePartialMatcher()) // comparing primitive types and manage numbers (100.00 == 100)
+    new LenientJsonArrayPartialMatcher(),
+    new LenientJsonObjectPartialMatcher(),
+    new StrictPrimitivePartialMatcher()
 );
 
-// generate a diff
-final var jsondiff = DiffGenerator.diff(expectedJson, receivedJson, jsonMatcher);
+// Generate the diff
+final var diff = DiffGenerator.diff(expectedJson, receivedJson, jsonMatcher);
 
-// use the viewer to collect diff data
-final var errorsResult= OnlyErrorDiffViewer.from(jsondiff);
+// Display errors
+System.out.println(OnlyErrorDiffViewer.from(diff));
 
-// print the diff result
-System.out.println(errorsResult);
-// print a similarity ratio between expected and received json (0 <= ratio <= 100)
-System.out.println(jsondiff.similarityRate());
+// Get similarity score (0-100)
+System.out.println("Similarity: " + diff.similarityRate() + "%");
 ```
-Result:
+
+Output:
 ```
-The property "$.additionalProperty" is not found
-The property "$.numberUnmatched" didn't match. Expected 10.01, Received: 10.02
-The property "$.arrayUnmatched" didn't match. Expected [{"b":"a"}], Received: {"b":"b"}
-The property "$.foo" didn't match. Expected "bar", Received: "foo"
+The property "$.city" is not found
+The property "$.name" didn't match. Expected "John", Received: "Jane"
 
-76.0
+Similarity: 50.0%
 ```
 
-You can also generate a patch file using this viewer: 
+## Output Formats
+
+### Error List (OnlyErrorDiffViewer)
+
 ```java
-final var patch = PatchDiffViewer.from(jsondiff);
+final var errors = OnlyErrorDiffViewer.from(diff);
+System.out.println(errors);
+```
 
-// use the viewer to collect diff data
-final var patchFile= PatchDiffViewer.from(jsondiff);
+Output:
+```
+The property "$.city" is not found
+The property "$.name" didn't match. Expected "John", Received: "Jane"
+```
 
-// print the diff result
-System.out.println(patchFile);
+### Patch Format (PatchDiffViewer)
+
+```java
+final var patch = PatchDiffViewer.from(diff);
+System.out.println(patch);
 ```
 
-Result:
-``` diff
+Output:
+```diff
 --- actual
 +++ expected
 @@ @@
  {
-+  "additionalProperty": "a",
-   "bar": "bar",
--  "numberUnmatched": 10.02,
-+  "numberUnmatched": 10.01,
--  "arrayUnmatched": {"b":"b"},
-+  "arrayUnmatched": [{"b":"a"}],
--  "foo": "foo",
-+  "foo": "bar",
-   "numberMatch": 10.0,
-   "arrayMatch": [
-     {
-       "b": "a"
-     }
-   ]
+   "age": 30,
++  "city": "Paris",
+-  "country": "France",
+-  "name": "Jane",
++  "name": "John"
  }
 ```
 
-### Comparison mode 
+## Comparison Modes
 
-You can use many comparison mode to compare you json: 
+`CompositeJsonMatcher` accepts multiple matchers that handle different JSON types. The order matters: the first matcher that can handle a comparison will be used.
 
-If you want compare json using *lenient* comparison:
-```java 
-final var fullLenient = new CompositeJsonMatcher(
-    new LenientJsonArrayPartialMatcher(), // comparing array using lenient mode (ignore array order and extra items)
-    new LenientJsonObjectPartialMatcher(), // comparing object using lenient mode (ignoring extra properties)
-    new LenientNumberPrimitivePartialMatcher(new StrictPrimitivePartialMatcher()) // comparing primitive types and manage numbers (100.00 == 100)
+### Strict Mode
+
+Requires exact matches:
+
+```java
+final var strictMatcher = new CompositeJsonMatcher(
+    new StrictJsonArrayPartialMatcher(),  // Same items in same order
+    new StrictJsonObjectPartialMatcher(), // Same properties, no extras
+    new StrictPrimitivePartialMatcher()   // Exact type and value match
 );
 ```
 
-If you want compare json using *strict* comparison:
-```java 
-final var strictMatcher = new CompositeJsonMatcher(
-    new StrictJsonArrayPartialMatcher(), // comparing array using strict mode (object should have same properties/value)
-    new StrictJsonObjectPartialMatcher(), // comparing object using strict mode (array should have same item on same orders)
-    new StrictPrimitivePartialMatcher() // comparing primitive types (values should be strictly equals type and value)
+### Lenient Mode
+
+Ignores extra properties and array order:
+
+```java
+final var lenientMatcher = new CompositeJsonMatcher(
+    new LenientJsonArrayPartialMatcher(),  // Ignores array order and extra items
+    new LenientJsonObjectPartialMatcher(), // Ignores extra properties
+    new LenientNumberPrimitivePartialMatcher(), // 10.0 == 10
+    new StrictPrimitivePartialMatcher()        // Other primitives
+);
+```
+
+### Mixed Mode
+
+You can combine matchers for custom behavior:
+
+```java
+final var mixedMatcher = new CompositeJsonMatcher(
+    new LenientJsonArrayPartialMatcher(),  // Lenient on arrays
+    new StrictJsonObjectPartialMatcher(),  // Strict on objects
+    new StrictPrimitivePartialMatcher()
+);
+```
+
+## Available Matchers
+
+### Array Matchers
+
+| Matcher | Description |
+|---------|-------------|
+| `LenientJsonArrayPartialMatcher` | Ignores array order and extra items |
+| `StrictJsonArrayPartialMatcher` | Requires same items in same order |
+
+### Object Matchers
+
+| Matcher | Description |
+|---------|-------------|
+| `LenientJsonObjectPartialMatcher` | Ignores extra properties in received JSON |
+| `StrictJsonObjectPartialMatcher` | Requires exact same properties |
+
+### Primitive Matchers
+
+| Matcher | Description |
+|---------|-------------|
+| `StrictPrimitivePartialMatcher` | Exact type and value match |
+| `LenientNumberPrimitivePartialMatcher` | Numbers are equal if values match (`10.0 == 10`) |
+
+### Special Matchers
+
+| Matcher | Description |
+|---------|-------------|
+| `NullEqualsEmptyArrayMatcher` | Treats `null` and `[]` as equivalent |
+
+## Treating Null as Empty Array
+
+The `NullEqualsEmptyArrayMatcher` allows you to consider `null` values and empty arrays `[]` as equivalent. This is useful when different systems represent "no data" differently.
+
+```java
+final var jsonMatcher = new CompositeJsonMatcher(
+    new NullEqualsEmptyArrayMatcher(),     // Must be first to handle null vs []
+    new LenientJsonArrayPartialMatcher(),
+    new LenientJsonObjectPartialMatcher(),
+    new StrictPrimitivePartialMatcher()
 );
+
+// These will match with 100% similarity:
+// {"items": null}  vs  {"items": []}
+// {"items": []}    vs  {"items": null}
+
+final var diff = DiffGenerator.diff(
+    "{\"items\": null}",
+    "{\"items\": []}",
+    jsonMatcher
+);
+
+System.out.println(diff.similarityRate()); // 100.0
 ```
 
-You can mix matcher. For example, be lenient on array and strict on object: 
-```java 
-final var matcher = new CompositeJsonMatcher(
-    new LenientJsonArrayPartialMatcher(), // comparing array using lenient mode (ignore array order and extra items)
-    new StrictJsonObjectPartialMatcher(), // comparing object using strict mode (array should have same item on same orders)
-    new StrictPrimitivePartialMatcher() // comparing primitive types (values should be strictly equals type and value)
+**Important:**
+- Place `NullEqualsEmptyArrayMatcher` **before** other matchers in the constructor
+- This matcher only handles `null` vs empty array `[]`, not missing properties
+- Non-empty arrays do not match `null`
+
+## Advanced Example
+
+```java
+final var expectedJson = """
+    {
+        "additionalProperty": "a",
+        "foo": "bar",
+        "bar": "bar",
+        "numberMatch": 10.0,
+        "numberUnmatched": 10.01,
+        "arrayMatch": [{"b": "a"}],
+        "arrayUnmatched": [{"b": "a"}]
+    }
+    """;
+
+final var receivedJson = """
+    {
+        "foo": "foo",
+        "bar": "bar",
+        "numberMatch": 10,
+        "numberUnmatched": 10.02,
+        "arrayMatch": [{"b": "a"}],
+        "arrayUnmatched": {"b": "b"}
+    }
+    """;
+
+final var jsonMatcher = new CompositeJsonMatcher(
+    new LenientJsonArrayPartialMatcher(),
+    new LenientJsonObjectPartialMatcher(),
+    new LenientNumberPrimitivePartialMatcher(),
+    new StrictPrimitivePartialMatcher()
 );
+
+final var diff = DiffGenerator.diff(expectedJson, receivedJson, jsonMatcher);
+
+System.out.println(OnlyErrorDiffViewer.from(diff));
+System.out.println("Similarity: " + diff.similarityRate() + "%");
+```
+
+Output:
+```
+The property "$.additionalProperty" is not found
+The property "$.numberUnmatched" didn't match. Expected 10.01, Received: 10.02
+The property "$.arrayUnmatched" didn't match. Expected [{"b":"a"}], Received: {"b":"b"}
+The property "$.foo" didn't match. Expected "bar", Received: "foo"
+
+Similarity: 76.0%
 ```
+
+## Creating Custom Matchers
+
+You can create custom matchers by implementing the `PartialJsonMatcher<T>` interface:
+
+```java
+public class MyCustomMatcher implements PartialJsonMatcher<JsonNode> {
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        // Return true if this matcher should handle this comparison
+        return /* your condition */;
+    }
+
+    @Override
+    public JsonDiff jsonDiff(Path path, JsonNode expected, JsonNode received, JsonMatcher jsonMatcher) {
+        // Return your diff result
+        if (/* values match */) {
+            return new MatchedPrimaryDiff(path, expected);
+        }
+        return new UnMatchedPrimaryDiff(path, expected, received);
+    }
+}
+```
+
+## License
+
+This project is licensed under the MIT License.
diff --git a/src/main/java/com/deblock/jsondiff/matcher/CompositeJsonMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/CompositeJsonMatcher.java
index 1db9e13..e8d83ff 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/CompositeJsonMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/CompositeJsonMatcher.java
@@ -6,32 +6,24 @@
 import tools.jackson.databind.node.ObjectNode;
 import tools.jackson.databind.node.ValueNode;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 public class CompositeJsonMatcher implements JsonMatcher {
-    private final PartialJsonMatcher<ArrayNode> jsonArrayPartialMatcher;
-    private final PartialJsonMatcher<ObjectNode> jsonObjectPartialMatcher;
-    private final PartialJsonMatcher<ValueNode> primitivePartialMatcher;
+    private final List<PartialJsonMatcher<JsonNode>> matchers;
 
-    public CompositeJsonMatcher(
-        PartialJsonMatcher<ArrayNode> jsonArrayPartialMatcher,
-        PartialJsonMatcher<ObjectNode> jsonObjectPartialMatcher,
-        PartialJsonMatcher<ValueNode> primitivePartialMatcher
-    ) {
-        this.jsonArrayPartialMatcher = jsonArrayPartialMatcher;
-        this.jsonObjectPartialMatcher = jsonObjectPartialMatcher;
-        this.primitivePartialMatcher = primitivePartialMatcher;
+    public CompositeJsonMatcher(PartialJsonMatcher<?> ...jsonArrayPartialMatcher) {
+        this.matchers = new ArrayList<>();
+        Arrays.stream(jsonArrayPartialMatcher).forEach(it -> this.matchers.add((PartialJsonMatcher<JsonNode>) it));
     }
 
     @Override
     public JsonDiff diff(Path path, JsonNode expected, JsonNode received) {
-        if (expected instanceof ObjectNode expectedObjectNode  && received instanceof ObjectNode receivedObjectNode) {
-            return this.jsonObjectPartialMatcher.jsonDiff(path, expectedObjectNode, receivedObjectNode, this);
-        } else if (expected instanceof ArrayNode expectedArrayNode && received instanceof ArrayNode receivedArrayNode) {
-            return this.jsonArrayPartialMatcher.jsonDiff(path, expectedArrayNode, receivedArrayNode, this);
-        } else if (expected instanceof ValueNode expectedValueNode && received instanceof ValueNode receivedValueNode){
-            return this.primitivePartialMatcher.jsonDiff(path, expectedValueNode, receivedValueNode, this);
-        } else {
-            return new UnMatchedPrimaryDiff(path, expected, received);
-        }
+        return this.matchers.stream()
+                .filter(matcher -> matcher.manage(expected, received))
+                .findFirst()
+                .map(matcher -> matcher.jsonDiff(path, expected, received, this))
+                .orElseGet(() -> new UnMatchedPrimaryDiff(path, expected, received));
     }
-
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/deblock/jsondiff/matcher/JsonMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/JsonMatcher.java
index 066e8ca..a2d34d5 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/JsonMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/JsonMatcher.java
@@ -6,5 +6,4 @@
 public interface JsonMatcher {
 
     JsonDiff diff(Path path, JsonNode expected, JsonNode received);
-
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/LenientJsonArrayPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/LenientJsonArrayPartialMatcher.java
index 0f479ab..d3f5dab 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/LenientJsonArrayPartialMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/LenientJsonArrayPartialMatcher.java
@@ -57,6 +57,11 @@ public JsonDiff jsonDiff(Path path, ArrayNode expectedArrayNode, ArrayNode recie
         return diff;
     }
 
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isArray() && received.isArray();
+    }
+
     private double maxSimilarityRate(Map.Entry<Integer, Map<Integer, JsonDiff>> entry) {
         return entry.getValue().values().stream().mapToDouble(JsonDiff::similarityRate).max().orElse(0);
     }
@@ -137,4 +142,4 @@ public boolean containsNode(JsonNode node) {
             return nodeCounter.containsKey(node);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/deblock/jsondiff/matcher/LenientJsonObjectPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/LenientJsonObjectPartialMatcher.java
index f3f65c3..b0b0d0f 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/LenientJsonObjectPartialMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/LenientJsonObjectPartialMatcher.java
@@ -2,6 +2,7 @@
 
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.JsonObjectDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ObjectNode;
 
 public class LenientJsonObjectPartialMatcher implements PartialJsonMatcher<ObjectNode> {
@@ -26,4 +27,9 @@ public JsonDiff jsonDiff(Path path, ObjectNode expectedJson, ObjectNode received
 
         return jsonDiff;
     }
-}
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isObject() && received.isObject();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcher.java
index a2bb13d..e471359 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcher.java
@@ -3,26 +3,39 @@
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
 import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
-import tools.jackson.databind.node.NumericNode;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ValueNode;
 
+/**
+ * A matcher that compares numeric values leniently.
+ * Two numbers are considered equal if their decimal values are equal,
+ * regardless of their representation (e.g., 10.0 == 10).
+ *
+ * <p>This matcher only handles numeric nodes. For other primitive types,
+ * add {@link StrictPrimitivePartialMatcher} to your {@link CompositeJsonMatcher}.</p>
+ *
+ * <p>Example usage:</p>
+ * <pre>
+ * new CompositeJsonMatcher(
+ *     new LenientJsonArrayPartialMatcher(),
+ *     new LenientJsonObjectPartialMatcher(),
+ *     new LenientNumberPrimitivePartialMatcher(),
+ *     new StrictPrimitivePartialMatcher()
+ * );
+ * </pre>
+ */
 public class LenientNumberPrimitivePartialMatcher implements PartialJsonMatcher<ValueNode> {
-    private final PartialJsonMatcher<ValueNode> delegated;
-
-    public LenientNumberPrimitivePartialMatcher(PartialJsonMatcher<ValueNode> delegated) {
-        this.delegated = delegated;
-    }
 
     @Override
     public JsonDiff jsonDiff(Path path, ValueNode expectedValue, ValueNode receivedValue, JsonMatcher jsonMatcher) {
-        if (expectedValue instanceof NumericNode && receivedValue instanceof NumericNode) {
-            if (expectedValue.decimalValue().compareTo(receivedValue.decimalValue()) != 0) {
-                return new UnMatchedPrimaryDiff(path, expectedValue, receivedValue);
-            } else {
-                return new MatchedPrimaryDiff(path, expectedValue);
-            }
+        if (expectedValue.decimalValue().compareTo(receivedValue.decimalValue()) != 0) {
+            return new UnMatchedPrimaryDiff(path, expectedValue, receivedValue);
         }
+        return new MatchedPrimaryDiff(path, expectedValue);
+    }
 
-        return delegated.jsonDiff(path, expectedValue, receivedValue, jsonMatcher);
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isNumber() && received.isNumber();
     }
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcher.java
new file mode 100644
index 0000000..35716c0
--- /dev/null
+++ b/src/main/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcher.java
@@ -0,0 +1,26 @@
+package com.deblock.jsondiff.matcher;
+
+import com.deblock.jsondiff.diff.JsonDiff;
+import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
+import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
+import tools.jackson.databind.JsonNode;
+
+public class NullEqualsEmptyArrayMatcher implements PartialJsonMatcher<JsonNode> {
+
+    @Override
+    public JsonDiff jsonDiff(Path path, JsonNode expectedJson, JsonNode receivedJson, JsonMatcher jsonMatcher) {
+        if (
+                (expectedJson.isNull() && receivedJson.isEmpty())
+                || (receivedJson.isNull() && expectedJson.isEmpty())
+        ) {
+            return new MatchedPrimaryDiff(path, expectedJson);
+        }
+        return new UnMatchedPrimaryDiff(path, expectedJson, receivedJson);
+    }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return (expected.isNull() && received.isArray())
+                 || (received.isNull() && expected.isArray());
+    }
+}
diff --git a/src/main/java/com/deblock/jsondiff/matcher/PartialJsonMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/PartialJsonMatcher.java
index d91cd8b..6d04e46 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/PartialJsonMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/PartialJsonMatcher.java
@@ -5,4 +5,7 @@
 
 public interface PartialJsonMatcher<T extends JsonNode> {
     JsonDiff jsonDiff(Path path, T expectedJson, T receivedJson, JsonMatcher jsonMatcher);
+
+    boolean manage(JsonNode expected, JsonNode received);
+
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/StrictJsonArrayPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/StrictJsonArrayPartialMatcher.java
index 9e7c73b..923786b 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/StrictJsonArrayPartialMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/StrictJsonArrayPartialMatcher.java
@@ -2,6 +2,7 @@
 
 import com.deblock.jsondiff.diff.JsonArrayDiff;
 import com.deblock.jsondiff.diff.JsonDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ArrayNode;
 
 import java.util.Comparator;
@@ -35,4 +36,9 @@ public JsonDiff jsonDiff(Path path, ArrayNode expectedValues, ArrayNode received
         }
         return diff;
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isArray() && received.isArray();
+    }
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/StrictJsonObjectPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/StrictJsonObjectPartialMatcher.java
index ba7291a..0103bc9 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/StrictJsonObjectPartialMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/StrictJsonObjectPartialMatcher.java
@@ -2,6 +2,7 @@
 
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.JsonObjectDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ObjectNode;
 
 public class StrictJsonObjectPartialMatcher implements PartialJsonMatcher<ObjectNode> {
@@ -37,4 +38,9 @@ public JsonDiff jsonDiff(Path path, ObjectNode expectedJson, ObjectNode received
 
         return jsonDiff;
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isObject() && received.isObject();
+    }
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/StrictPrimitivePartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/StrictPrimitivePartialMatcher.java
index 8c7df2e..c6e4601 100644
--- a/src/main/java/com/deblock/jsondiff/matcher/StrictPrimitivePartialMatcher.java
+++ b/src/main/java/com/deblock/jsondiff/matcher/StrictPrimitivePartialMatcher.java
@@ -3,6 +3,7 @@
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
 import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ValueNode;
 
 import java.util.Objects;
@@ -17,4 +18,9 @@ public JsonDiff jsonDiff(Path path, ValueNode expectedValue, ValueNode receivedV
             return new UnMatchedPrimaryDiff(path, expectedValue, receivedValue);
         }
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isValueNode() && received.isValueNode();
+    }
 }
diff --git a/src/test/java/com/deblock/jsondiff/Sample.java b/src/test/java/com/deblock/jsondiff/Sample.java
index 5cb7ca4..daf3426 100644
--- a/src/test/java/com/deblock/jsondiff/Sample.java
+++ b/src/test/java/com/deblock/jsondiff/Sample.java
@@ -6,15 +6,17 @@
 
 public class Sample {
     public static void main(String[] args) {
-        final var expectedJson = "{\"array\": [{\"b\": [1]}, {\"a\": [1, 5]}]}";
-        final var receivedJson = "{\"array\": [{\"a\": [1]}]}";
+        final var expectedJson = "{\"array\": []}";
+        final var receivedJson = "{}";
 
         // define your matcher
         // CompositeJsonMatcher use other matcher to perform matching on objects, list or primitive
         final var jsonMatcher = new CompositeJsonMatcher(
+            new NullEqualsEmptyArrayMatcher(),
             new LenientJsonArrayPartialMatcher(), // comparing array using lenient mode (ignore array order and extra items)
             new LenientJsonObjectPartialMatcher(), // comparing object using lenient mode (ignoring extra properties)
-            new LenientNumberPrimitivePartialMatcher(new StrictPrimitivePartialMatcher()) // comparing primitive types and manage numbers (100.00 == 100)
+            new LenientNumberPrimitivePartialMatcher(), // comparing numbers leniently (100.00 == 100)
+            new StrictPrimitivePartialMatcher() // comparing other primitive types strictly
         );
 
         // generate a diff
diff --git a/src/test/java/com/deblock/jsondiff/integration/NullEqualsEmptyArrayMatcherIntegrationTest.java b/src/test/java/com/deblock/jsondiff/integration/NullEqualsEmptyArrayMatcherIntegrationTest.java
new file mode 100644
index 0000000..6b1bc27
--- /dev/null
+++ b/src/test/java/com/deblock/jsondiff/integration/NullEqualsEmptyArrayMatcherIntegrationTest.java
@@ -0,0 +1,107 @@
+package com.deblock.jsondiff.integration;
+
+import com.deblock.jsondiff.DiffGenerator;
+import com.deblock.jsondiff.matcher.*;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class NullEqualsEmptyArrayMatcherIntegrationTest {
+
+    private final CompositeJsonMatcher jsonMatcher = new CompositeJsonMatcher(
+        new NullEqualsEmptyArrayMatcher(),
+        new LenientJsonArrayPartialMatcher(),
+        new LenientJsonObjectPartialMatcher(),
+        new StrictPrimitivePartialMatcher()
+    );
+
+    @Test
+    public void shouldMatchNullAndEmptyArray() {
+        final var expected = "{\"items\": null}";
+        final var received = "{\"items\": []}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+
+    @Test
+    public void shouldMatchEmptyArrayAndNull() {
+        final var expected = "{\"items\": []}";
+        final var received = "{\"items\": null}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+
+    @Test
+    public void shouldNotMatchNullAndNonEmptyArray() {
+        final var expected = "{\"items\": null}";
+        final var received = "{\"items\": [1, 2, 3]}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertTrue(diff.similarityRate() < 100.0);
+    }
+
+    @Test
+    public void shouldMatchNullAndEmptyArrayInNestedObject() {
+        final var expected = "{\"data\": {\"items\": null, \"name\": \"test\"}}";
+        final var received = "{\"data\": {\"items\": [], \"name\": \"test\"}}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+
+    @Test
+    public void shouldMatchNullAndEmptyArrayInDeeplyNestedStructure() {
+        final var expected = "{\"level1\": {\"level2\": {\"level3\": {\"items\": null}}}}";
+        final var received = "{\"level1\": {\"level2\": {\"level3\": {\"items\": []}}}}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+
+    @Test
+    public void shouldMatchNullAndEmptyArrayInsideArray() {
+        final var expected = "{\"data\": [{\"items\": null}, {\"items\": [1]}]}";
+        final var received = "{\"data\": [{\"items\": []}, {\"items\": [1]}]}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+
+    @Test
+    public void shouldMatchMultipleNullAndEmptyArrayFields() {
+        final var expected = "{\"array1\": null, \"array2\": null, \"value\": \"test\"}";
+        final var received = "{\"array1\": [], \"array2\": [], \"value\": \"test\"}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+
+    @Test
+    public void shouldNotMatchEmptyArrayAndMissingProperty() {
+        final var expected = "{\"items\": []}";
+        final var received = "{}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertTrue(diff.similarityRate() < 100.0, "Empty array should not match missing property");
+    }
+
+    @Test
+    public void shouldNotMatchMissingPropertyAndEmptyArray() {
+        final var expected = "{}";
+        final var received = "{\"items\": []}";
+
+        final var diff = DiffGenerator.diff(expected, received, jsonMatcher);
+
+        assertEquals(100.0, diff.similarityRate());
+    }
+}
diff --git a/src/test/java/com/deblock/jsondiff/matcher/CompositeJsonMatcherTest.java b/src/test/java/com/deblock/jsondiff/matcher/CompositeJsonMatcherTest.java
index c44adf4..bfadf03 100644
--- a/src/test/java/com/deblock/jsondiff/matcher/CompositeJsonMatcherTest.java
+++ b/src/test/java/com/deblock/jsondiff/matcher/CompositeJsonMatcherTest.java
@@ -1,11 +1,13 @@
 package com.deblock.jsondiff.matcher;
 
 import com.deblock.jsondiff.diff.JsonDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.*;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
 
 public class CompositeJsonMatcherTest {
     private final static Path path = Path.ROOT.add(Path.PathItem.of("property"));
@@ -16,10 +18,20 @@ public void shouldCallTheArrayMatcherIfTheTwoObjectAreArray() {
         final var array2 = new ArrayNode(null);
 
         final var arrayMatcher = (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class);
+        final var objectMatcher = (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class);
+        final var primitiveMatcher = (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class);
+
+        Mockito.when(arrayMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isArray() && ((JsonNode)inv.getArgument(1)).isArray());
+        Mockito.when(objectMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isObject() && ((JsonNode)inv.getArgument(1)).isObject());
+        Mockito.when(primitiveMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isValueNode() && ((JsonNode)inv.getArgument(1)).isValueNode());
+
         final var compositeMatcher = new CompositeJsonMatcher(
             arrayMatcher,
-            (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class),
-            (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class)
+            objectMatcher,
+            primitiveMatcher
         );
         final var expectedJsonDiff = Mockito.mock(JsonDiff.class);
         Mockito.when(arrayMatcher.jsonDiff(path, array1, array2, compositeMatcher)).thenReturn(expectedJsonDiff);
@@ -34,11 +46,21 @@ public void shouldCallTheObjectMatcherIfTheTwoObjectAreObject() {
         final var object1 = new ObjectNode(null);
         final var object2 = new ObjectNode(null);
 
+        final var arrayMatcher = (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class);
         final var objectMatcher = (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class);
+        final var primitiveMatcher = (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class);
+
+        Mockito.when(arrayMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isArray() && ((JsonNode)inv.getArgument(1)).isArray());
+        Mockito.when(objectMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isObject() && ((JsonNode)inv.getArgument(1)).isObject());
+        Mockito.when(primitiveMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isValueNode() && ((JsonNode)inv.getArgument(1)).isValueNode());
+
         final var compositeMatcher = new CompositeJsonMatcher(
-            (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class),
+            arrayMatcher,
             objectMatcher,
-            (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class)
+            primitiveMatcher
         );
         final var expectedJsonDiff = Mockito.mock(JsonDiff.class);
         Mockito.when(objectMatcher.jsonDiff(path, object1, object2, compositeMatcher)).thenReturn(expectedJsonDiff);
@@ -53,10 +75,20 @@ public void shouldCallThePrimitiveMatcherIfTheTwoObjectAreValue() {
         final var value1 = StringNode.valueOf("");
         final var value2 = IntNode.valueOf(10);
 
+        final var arrayMatcher = (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class);
+        final var objectMatcher = (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class);
         final var primitiveMatcher = (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class);
+
+        Mockito.when(arrayMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isArray() && ((JsonNode)inv.getArgument(1)).isArray());
+        Mockito.when(objectMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isObject() && ((JsonNode)inv.getArgument(1)).isObject());
+        Mockito.when(primitiveMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isValueNode() && ((JsonNode)inv.getArgument(1)).isValueNode());
+
         final var compositeMatcher = new CompositeJsonMatcher(
-            (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class),
-            (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class),
+            arrayMatcher,
+            objectMatcher,
             primitiveMatcher
         );
         final var expectedJsonDiff = Mockito.mock(JsonDiff.class);
@@ -72,10 +104,21 @@ public void shouldReturnANonMatchWhenTypesAreDifferent() {
         final var value1 = StringNode.valueOf("");
         final var value2 = new ObjectNode(null);
 
+        final var arrayMatcher = (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class);
+        final var objectMatcher = (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class);
+        final var primitiveMatcher = (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class);
+
+        Mockito.when(arrayMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isArray() && ((JsonNode)inv.getArgument(1)).isArray());
+        Mockito.when(objectMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isObject() && ((JsonNode)inv.getArgument(1)).isObject());
+        Mockito.when(primitiveMatcher.manage(any(), any())).thenAnswer(inv ->
+            ((JsonNode)inv.getArgument(0)).isValueNode() && ((JsonNode)inv.getArgument(1)).isValueNode());
+
         final var compositeMatcher = new CompositeJsonMatcher(
-            (PartialJsonMatcher<ArrayNode>) Mockito.mock(PartialJsonMatcher.class),
-            (PartialJsonMatcher<ObjectNode>) Mockito.mock(PartialJsonMatcher.class),
-            (PartialJsonMatcher<ValueNode>) Mockito.mock(PartialJsonMatcher.class)
+            arrayMatcher,
+            objectMatcher,
+            primitiveMatcher
         );
 
         final var result = compositeMatcher.diff(path, value1, value2);
diff --git a/src/test/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcherTest.java b/src/test/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcherTest.java
index 72695ac..1218fd4 100644
--- a/src/test/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcherTest.java
+++ b/src/test/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcherTest.java
@@ -1,26 +1,66 @@
 package com.deblock.jsondiff.matcher;
 
-import com.deblock.jsondiff.diff.JsonDiff;
 import tools.jackson.databind.node.DecimalNode;
 import tools.jackson.databind.node.IntNode;
 import tools.jackson.databind.node.StringNode;
+import tools.jackson.databind.node.BooleanNode;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import java.math.BigDecimal;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class LenientNumberPrimitivePartialMatcherTest {
     private final static Path expectedPath = Path.ROOT.add(Path.PathItem.of("property"));
+    private final LenientNumberPrimitivePartialMatcher matcher = new LenientNumberPrimitivePartialMatcher();
 
     @Test
-    public void shouldReturnAMatchIfNodeAreStrictEqualsNumbers() {
+    void manage_shouldReturnTrue_whenBothNodesAreNumbers() {
+        final var number1 = IntNode.valueOf(10);
+        final var number2 = DecimalNode.valueOf(BigDecimal.valueOf(20));
+
+        assertTrue(matcher.manage(number1, number2));
+    }
+
+    @Test
+    void manage_shouldReturnFalse_whenExpectedIsNotNumber() {
+        final var string = StringNode.valueOf("test");
+        final var number = IntNode.valueOf(10);
+
+        assertFalse(matcher.manage(string, number));
+    }
+
+    @Test
+    void manage_shouldReturnFalse_whenReceivedIsNotNumber() {
+        final var number = IntNode.valueOf(10);
+        final var string = StringNode.valueOf("test");
+
+        assertFalse(matcher.manage(number, string));
+    }
+
+    @Test
+    void manage_shouldReturnFalse_whenBothAreStrings() {
+        final var string1 = StringNode.valueOf("test1");
+        final var string2 = StringNode.valueOf("test2");
+
+        assertFalse(matcher.manage(string1, string2));
+    }
+
+    @Test
+    void manage_shouldReturnFalse_whenBothAreBooleans() {
+        final var bool1 = BooleanNode.TRUE;
+        final var bool2 = BooleanNode.FALSE;
+
+        assertFalse(matcher.manage(bool1, bool2));
+    }
+
+    @Test
+    void shouldReturnAMatchIfNodeAreStrictEqualsNumbers() {
         final var number1 = DecimalNode.valueOf(BigDecimal.valueOf(101, 1));
         final var number2 = DecimalNode.valueOf(BigDecimal.valueOf(101, 1));
 
-        final var jsonDiff = new LenientNumberPrimitivePartialMatcher(null)
-                .jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
+        final var jsonDiff = matcher.jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
 
         assertEquals(100, jsonDiff.similarityRate());
         assertEquals(expectedPath, jsonDiff.path());
@@ -30,12 +70,11 @@ public void shouldReturnAMatchIfNodeAreStrictEqualsNumbers() {
     }
 
     @Test
-    public void shouldReturnAMatchIfNodeAreEqualsNumbersWithDifferentType() {
+    void shouldReturnAMatchIfNodeAreEqualsNumbersWithDifferentType() {
         final var number1 = IntNode.valueOf(100);
         final var number2 = DecimalNode.valueOf(BigDecimal.valueOf(1000, 1));
 
-        final var jsonDiff = new LenientNumberPrimitivePartialMatcher(null)
-                .jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
+        final var jsonDiff = matcher.jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
 
         assertEquals(100, jsonDiff.similarityRate());
         assertEquals(expectedPath, jsonDiff.path());
@@ -45,12 +84,11 @@ public void shouldReturnAMatchIfNodeAreEqualsNumbersWithDifferentType() {
     }
 
     @Test
-    public void shouldReturnANonMatchIfNodeAreEqualsNumbersWithDifferentDecimalValue() {
+    void shouldReturnANonMatchIfNodeAreEqualsNumbersWithDifferentDecimalValue() {
         final var number1 = DecimalNode.valueOf(BigDecimal.valueOf(1000, 1));
         final var number2 = DecimalNode.valueOf(BigDecimal.valueOf(1001, 1));
 
-        final var jsonDiff = new LenientNumberPrimitivePartialMatcher(null)
-                .jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
+        final var jsonDiff = matcher.jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
 
         assertEquals(0, jsonDiff.similarityRate());
         assertEquals(expectedPath, jsonDiff.path());
@@ -60,12 +98,11 @@ public void shouldReturnANonMatchIfNodeAreEqualsNumbersWithDifferentDecimalValue
     }
 
     @Test
-    public void shouldReturnANonMatchIfNodeAreEqualsNumbersWithDifferentIntValue() {
+    void shouldReturnANonMatchIfNodeAreEqualsNumbersWithDifferentIntValue() {
         final var number1 = DecimalNode.valueOf(BigDecimal.valueOf(1000, 1));
         final var number2 = DecimalNode.valueOf(BigDecimal.valueOf(2000, 1));
 
-        final var jsonDiff = new LenientNumberPrimitivePartialMatcher(null)
-                .jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
+        final var jsonDiff = matcher.jsonDiff(expectedPath, number1, number2, Mockito.mock(JsonMatcher.class));
 
         assertEquals(0, jsonDiff.similarityRate());
         assertEquals(expectedPath, jsonDiff.path());
@@ -73,19 +110,4 @@ public void shouldReturnANonMatchIfNodeAreEqualsNumbersWithDifferentIntValue() {
                 .assertPrimaryNonMatching(expectedPath)
                 .validate(jsonDiff);
     }
-
-    @Test
-    public void shouldCallTheDelegatedIfNodeHaveDifferentType() {
-        final var value1 = IntNode.valueOf(100);
-        final var value2 = StringNode.valueOf("100");
-        final var jsonMatcher = Mockito.mock(JsonMatcher.class);
-        final var delegated = Mockito.mock(PartialJsonMatcher.class);
-        final var expectedJsonDiff = Mockito.mock(JsonDiff.class);
-        Mockito.when(delegated.jsonDiff(expectedPath, value1, value2, jsonMatcher)).thenReturn(expectedJsonDiff);
-
-        final var jsonDiff = new LenientNumberPrimitivePartialMatcher(delegated)
-                .jsonDiff(expectedPath, value1, value2, jsonMatcher);
-
-        assertEquals(expectedJsonDiff, jsonDiff);
-    }
 }
diff --git a/src/test/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcherTest.java b/src/test/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcherTest.java
new file mode 100644
index 0000000..56954e9
--- /dev/null
+++ b/src/test/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcherTest.java
@@ -0,0 +1,104 @@
+package com.deblock.jsondiff.matcher;
+
+import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
+import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
+import org.junit.jupiter.api.Test;
+import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.node.ArrayNode;
+import tools.jackson.databind.node.NullNode;
+import tools.jackson.databind.node.ObjectNode;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class NullEqualsEmptyArrayMatcherTest {
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final Path ROOT = Path.ROOT;
+    private final NullEqualsEmptyArrayMatcher matcher = new NullEqualsEmptyArrayMatcher();
+
+    @Test
+    public void manage_shouldReturnTrue_whenExpectedIsNullAndReceivedIsArray() {
+        final var nullNode = NullNode.getInstance();
+        final var arrayNode = MAPPER.createArrayNode();
+
+        assertTrue(matcher.manage(nullNode, arrayNode));
+    }
+
+    @Test
+    public void manage_shouldReturnTrue_whenExpectedIsArrayAndReceivedIsNull() {
+        final var arrayNode = MAPPER.createArrayNode();
+        final var nullNode = NullNode.getInstance();
+
+        assertTrue(matcher.manage(arrayNode, nullNode));
+    }
+
+    @Test
+    public void manage_shouldReturnFalse_whenBothAreNull() {
+        final var nullNode1 = NullNode.getInstance();
+        final var nullNode2 = NullNode.getInstance();
+
+        assertFalse(matcher.manage(nullNode1, nullNode2));
+    }
+
+    @Test
+    public void manage_shouldReturnFalse_whenBothAreArrays() {
+        final var array1 = MAPPER.createArrayNode();
+        final var array2 = MAPPER.createArrayNode();
+
+        assertFalse(matcher.manage(array1, array2));
+    }
+
+    @Test
+    public void manage_shouldReturnFalse_whenExpectedIsNullAndReceivedIsObject() {
+        final var nullNode = NullNode.getInstance();
+        final var objectNode = MAPPER.createObjectNode();
+
+        assertFalse(matcher.manage(nullNode, objectNode));
+    }
+
+    @Test
+    public void jsonDiff_shouldReturnMatch_whenNullVsEmptyArray() {
+        final var nullNode = NullNode.getInstance();
+        final var emptyArray = MAPPER.createArrayNode();
+
+        final var result = matcher.jsonDiff(ROOT, nullNode, emptyArray, null);
+
+        assertInstanceOf(MatchedPrimaryDiff.class, result);
+        assertEquals(100.0, result.similarityRate());
+    }
+
+    @Test
+    public void jsonDiff_shouldReturnMatch_whenEmptyArrayVsNull() {
+        final var emptyArray = MAPPER.createArrayNode();
+        final var nullNode = NullNode.getInstance();
+
+        final var result = matcher.jsonDiff(ROOT, emptyArray, nullNode, null);
+
+        assertInstanceOf(MatchedPrimaryDiff.class, result);
+        assertEquals(100.0, result.similarityRate());
+    }
+
+    @Test
+    public void jsonDiff_shouldReturnUnMatch_whenNullVsNonEmptyArray() {
+        final var nullNode = NullNode.getInstance();
+        final var nonEmptyArray = MAPPER.createArrayNode();
+        nonEmptyArray.add(1);
+
+        final var result = matcher.jsonDiff(ROOT, nullNode, nonEmptyArray, null);
+
+        assertInstanceOf(UnMatchedPrimaryDiff.class, result);
+        assertEquals(0.0, result.similarityRate());
+    }
+
+    @Test
+    public void jsonDiff_shouldReturnUnMatch_whenNonEmptyArrayVsNull() {
+        final var nonEmptyArray = MAPPER.createArrayNode();
+        nonEmptyArray.add("value");
+        final var nullNode = NullNode.getInstance();
+
+        final var result = matcher.jsonDiff(ROOT, nonEmptyArray, nullNode, null);
+
+        assertInstanceOf(UnMatchedPrimaryDiff.class, result);
+        assertEquals(0.0, result.similarityRate());
+    }
+
+}
diff --git a/src/test/java/com/deblock/jsondiff/viewer/PatchDiffViewerTest.java b/src/test/java/com/deblock/jsondiff/viewer/PatchDiffViewerTest.java
index 59b3c25..84206e5 100644
--- a/src/test/java/com/deblock/jsondiff/viewer/PatchDiffViewerTest.java
+++ b/src/test/java/com/deblock/jsondiff/viewer/PatchDiffViewerTest.java
@@ -25,7 +25,8 @@ public void diffTestUsingLenientDiff() throws IOException {
         final var jsonMatcher = new CompositeJsonMatcher(
                 new LenientJsonArrayPartialMatcher(),
                 new LenientJsonObjectPartialMatcher(),
-                new LenientNumberPrimitivePartialMatcher(new StrictPrimitivePartialMatcher())
+                new LenientNumberPrimitivePartialMatcher(),
+                new StrictPrimitivePartialMatcher()
         );
         final var jsondiff = DiffGenerator.diff(expectedJson, actualJson, jsonMatcher);