Migrate yang-data-tree-spi to JUnit5

Migrated all tests to use JUnit5 Assertions, using openrewrite:rewrite-testing-frameworks.

JIRA: YANGTOOLS-1521
Change-Id: I7670aa3b290b21e5e7c47a70316550fbfa4164d6
Signed-off-by: matus.matok <matus.matok@pantheon.tech>
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
Signed-off-by: matus.matok <matus.matok@pantheon.tech>

diff --git a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidateNodesTest.java b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidateNodesTest.java
index 75018ec8702fcf6e1163df19127900f7f471ca87..f177cc91b5d3ceafe886b223e19d035635eafe94 100644 (file)
--- a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidateNodesTest.java
+++ b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidateNodesTest.java
@@ -7,10 +7,9 @@
  */
 package org.opendaylight.yangtools.yang.data.tree.spi;
 
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.doReturn;
@@ -19,9 +18,7 @@ import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@@ -29,31 +26,27 @@ import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModificationCursor;
 import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
 
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class DataTreeCandidateNodesTest {
+class DataTreeCandidateNodesTest {
     @Test
-    public void testFromNormalizedNode() {
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
-        final DataTreeCandidateNode dataTreeCandidateNode = DataTreeCandidateNodes.written(mockedNormalizedNode);
-        assertNotNull(dataTreeCandidateNode);
+    void testFromNormalizedNode() {
+        assertNotNull(DataTreeCandidateNodes.written(mock(NormalizedNode.class)));
     }
 
     @Test
-    public void testApplyToCursorWithWriteModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyToCursorWithWriteModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.WRITE).when(mockedDataTreeCandidateNode).modificationType();
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
-        doReturn(mockedNormalizedNode).when(mockedDataTreeCandidateNode).dataAfter();
+        doReturn(mock(NormalizedNode.class)).when(mockedDataTreeCandidateNode).dataAfter();
         DataTreeCandidateNodes.applyToCursor(mockedCursor, mockedDataTreeCandidateNode);
         verify(mockedCursor, times(1)).write(isNull(), any(NormalizedNode.class));
     }
 
     @Test
-    public void testApplyToCursorWithDeleteModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyToCursorWithDeleteModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).modificationType();
         DataTreeCandidateNodes.applyToCursor(mockedCursor, mockedDataTreeCandidateNode);
@@ -61,23 +54,22 @@ public class DataTreeCandidateNodesTest {
     }
 
     @Test
-    public void testApplyToCursorWithSubtreeModifiedModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyToCursorWithSubtreeModifiedModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).modificationType();
 
-        final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode1 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedChildNode1).modificationType();
 
-        final DataTreeCandidateNode mockedChildNode2 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode2 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.WRITE).when(mockedChildNode2).modificationType();
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
-        doReturn(mockedNormalizedNode).when(mockedChildNode2).dataAfter();
+        doReturn(mock(NormalizedNode.class)).when(mockedChildNode2).dataAfter();
 
-        final DataTreeCandidateNode mockedChildNode3 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode3 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedChildNode3).modificationType();
-        final DataTreeCandidateNode mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedChildNode3ChildNode).modificationType();
         doReturn(List.of(mockedChildNode3ChildNode)).when(mockedChildNode3).childNodes();
 
@@ -91,33 +83,32 @@ public class DataTreeCandidateNodesTest {
     }
 
     @Test
-    public void testApplyToCursorWithUnsupportedModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyToCursorWithUnsupportedModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).modificationType();
-        final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+        final var ex = assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidateNodes.applyToCursor(mockedCursor, mockedDataTreeCandidateNode));
-        assertThat(ex.getMessage(), containsString("Unsupported modification"));
+        assertEquals("Unsupported modification APPEARED", ex.getMessage());
     }
 
     @Test
-    public void testApplyRootedNodeToCursorWithWriteModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyRootedNodeToCursorWithWriteModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.WRITE).when(mockedDataTreeCandidateNode).modificationType();
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
-        doReturn(mockedNormalizedNode).when(mockedDataTreeCandidateNode).dataAfter();
+        doReturn(mock(NormalizedNode.class)).when(mockedDataTreeCandidateNode).dataAfter();
         DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
             mockedDataTreeCandidateNode);
         verify(mockedCursor, times(1)).write(isNull(), any(NormalizedNode.class));
     }
 
     @Test
-    public void testApplyRootedNodeToCursorWithDeleteModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyRootedNodeToCursorWithDeleteModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).modificationType();
         DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
@@ -126,13 +117,13 @@ public class DataTreeCandidateNodesTest {
     }
 
     @Test
-    public void testApplyRootedNodeToCursorWithSubtreeModifiedModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyRootedNodeToCursorWithSubtreeModifiedModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).modificationType();
 
-        final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode1 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedChildNode1).modificationType();
         doReturn(List.of(mockedChildNode1)).when(mockedDataTreeCandidateNode).childNodes();
 
@@ -143,25 +134,25 @@ public class DataTreeCandidateNodesTest {
     }
 
     @Test
-    public void testApplyRootedNodeToCursorWithUnsupportedModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyRootedNodeToCursorWithUnsupportedModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).modificationType();
-        final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+        final var ex = assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
                 mockedDataTreeCandidateNode));
-        assertThat(ex.getMessage(), containsString("Unsupported modification"));
+        assertEquals("Unsupported modification APPEARED", ex.getMessage());
     }
 
     @Test
-    public void testApplyRootToCursorWithSubtreeModifiedModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyRootToCursorWithSubtreeModifiedModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).modificationType();
 
-        final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode1 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedChildNode1).modificationType();
         doReturn(List.of(mockedChildNode1)).when(mockedDataTreeCandidateNode).childNodes();
 
@@ -170,24 +161,24 @@ public class DataTreeCandidateNodesTest {
     }
 
     @Test
-    public void testApplyRootToCursorWithDeleteModificationType() {
+    void testApplyRootToCursorWithDeleteModificationType() {
         final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).modificationType();
         final var ex = assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidateNodes.applyRootToCursor(mockedCursor, mockedDataTreeCandidateNode));
-        assertThat(ex.getMessage(), containsString("Can not delete root"));
+        assertEquals("Can not delete root.", ex.getMessage());
     }
 
     @Test
-    public void testApplyRootToCursorWithUnsupportedModificationType() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyRootToCursorWithUnsupportedModificationType() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
         doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).modificationType();
-        final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+        final var ex = assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidateNodes.applyRootToCursor(mockedCursor, mockedDataTreeCandidateNode));
-        assertThat(ex.getMessage(), containsString("Unsupported modification"));
+        assertEquals("Unsupported modification APPEARED", ex.getMessage());
     }
 }

diff --git a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesAggregateTest.java b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesAggregateTest.java
index 7f08eb5359f82884ca5193deb4d420ac6d725d8f..d9b2098e5b2f8be3f73ca92e03ff0482a5f0e8d0 100644 (file)
--- a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesAggregateTest.java
+++ b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesAggregateTest.java
@@ -7,9 +7,9 @@
  */
 package org.opendaylight.yangtools.yang.data.tree.spi;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.opendaylight.yangtools.yang.data.tree.api.ModificationType.APPEARED;
@@ -20,7 +20,7 @@ import static org.opendaylight.yangtools.yang.data.tree.api.ModificationType.UNM
 import static org.opendaylight.yangtools.yang.data.tree.api.ModificationType.WRITE;
 
 import java.util.List;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@@ -30,7 +30,7 @@ import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
 import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
 
-public class DataTreeCandidatesAggregateTest {
+class DataTreeCandidatesAggregateTest {
     private static final YangInstanceIdentifier ROOT_PATH = YangInstanceIdentifier.of(QName.create(
             "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test:container",
             "2014-03-13", "container"));
@@ -39,18 +39,18 @@ public class DataTreeCandidatesAggregateTest {
             "2014-03-13", "data"));
 
     @Test
-    public void testLeafUnmodifiedUnmodified() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value1");
-        NormalizedNode normalizedNode3 = normalizedNode("value1");
+    void testLeafUnmodifiedUnmodified() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value1");
+        final var normalizedNode3 = normalizedNode("value1");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, UNMODIFIED);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, UNMODIFIED);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode3, UNMODIFIED);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode3, UNMODIFIED);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
         assertEquals("value1", aggregationResult.getRootNode().dataBefore().body());
@@ -58,18 +58,18 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeaftUnmodifiedWrite() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value1");
-        NormalizedNode normalizedNode3 = normalizedNode("value2");
+    void testLeaftUnmodifiedWrite() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value1");
+        final var normalizedNode3 = normalizedNode("value2");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, UNMODIFIED);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, UNMODIFIED);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode3, WRITE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode3, WRITE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
         assertEquals("value1", aggregationResult.getRootNode().dataBefore().body());
@@ -77,15 +77,15 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafUnmodifiedDelete() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value1");
+    void testLeafUnmodifiedDelete() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value1");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, UNMODIFIED);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, UNMODIFIED);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode2, null, DELETE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode2, null, DELETE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
@@ -95,41 +95,41 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafUnmodifiedDeleteWithoutDataBefore() {
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+    void testLeafUnmodifiedDeleteWithoutDataBefore() {
+        final var node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, DELETE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, null, DELETE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testLeafUnmodifiedSubtreeModifiedWithoutDataBefore() {
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+    void testLeafUnmodifiedSubtreeModifiedWithoutDataBefore() {
+        final var node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, SUBTREE_MODIFIED);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, null, SUBTREE_MODIFIED);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testLeafWriteUnmodified() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value2");
+    void testLeafWriteUnmodified() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value2");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, WRITE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, WRITE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode2, UNMODIFIED);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode2, UNMODIFIED);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
         assertEquals("value1", aggregationResult.getRootNode().dataBefore().body());
@@ -137,18 +137,18 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafWriteWrite() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value2");
-        NormalizedNode normalizedNode3 = normalizedNode("value3");
+    void testLeafWriteWrite() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value2");
+        final var normalizedNode3 = normalizedNode("value3");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, WRITE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, WRITE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode3, WRITE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode2, normalizedNode3, WRITE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
         assertEquals("value1", aggregationResult.getRootNode().dataBefore().body());
@@ -156,34 +156,34 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafWriteDeleteWithoutChanges() {
-        NormalizedNode normalizedNode = normalizedNode("value1");
+    void testLeafWriteDeleteWithoutChanges() {
+        final var normalizedNode = normalizedNode("value1");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(null, normalizedNode, WRITE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(null, normalizedNode, WRITE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode, null, DELETE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode, null, DELETE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
-        assertEquals(null, aggregationResult.getRootNode().dataBefore());
-        assertEquals(null, aggregationResult.getRootNode().dataAfter());
+        assertNull(aggregationResult.getRootNode().dataBefore());
+        assertNull(aggregationResult.getRootNode().dataAfter());
     }
 
     @Test
-    public void testLeafWriteDelete() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value2");
+    void testLeafWriteDelete() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value2");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, WRITE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, normalizedNode2, WRITE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(normalizedNode2, null, DELETE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(normalizedNode2, null, DELETE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DELETE, aggregationResult.getRootNode().modificationType());
         assertEquals("value1", aggregationResult.getRootNode().dataBefore().body());
@@ -191,16 +191,16 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafDeleteUnmodified() {
-        NormalizedNode normalizedNode = normalizedNode("value");
+    void testLeafDeleteUnmodified() {
+        final var normalizedNode = normalizedNode("value");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode, null, DELETE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode, null, DELETE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DELETE, aggregationResult.getRootNode().modificationType());
         assertEquals("value", aggregationResult.getRootNode().dataBefore().body());
@@ -208,17 +208,17 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafDeleteWrite() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
-        NormalizedNode normalizedNode2 = normalizedNode("value2");
+    void testLeafDeleteWrite() {
+        final var normalizedNode1 = normalizedNode("value1");
+        final var normalizedNode2 = normalizedNode("value2");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, normalizedNode2, WRITE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, normalizedNode2, WRITE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
         assertEquals("value1", aggregationResult.getRootNode().dataBefore().body());
@@ -226,123 +226,123 @@ public class DataTreeCandidatesAggregateTest {
     }
 
     @Test
-    public void testLeafDeleteDelete() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
+    void testLeafDeleteDelete() {
+        final var normalizedNode1 = normalizedNode("value1");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, DELETE);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, null, DELETE);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testLeafDeleteDisappear() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
+    void testLeafDeleteDisappear() {
+        final var normalizedNode1 = normalizedNode("value1");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, DISAPPEARED);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, null, DISAPPEARED);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testLeafDeleteSubtreeModified() {
-        NormalizedNode normalizedNode1 = normalizedNode("value1");
+    void testLeafDeleteSubtreeModified() {
+        final var normalizedNode1 = normalizedNode("value1");
 
-        DataTreeCandidateNode node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var node1 = dataTreeCandidateNode(normalizedNode1, null, DELETE);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        DataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, SUBTREE_MODIFIED);
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var node2 = dataTreeCandidateNode(null, null, SUBTREE_MODIFIED);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testUnmodifiedUnmodified() throws NoSuchFieldException {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testUnmodifiedUnmodified() throws NoSuchFieldException {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
+        final var node1 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
+        final var node2 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testUnmodifiedDelete() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testUnmodifiedDelete() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
+        final var node1 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, null, DELETE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode, null, DELETE);
+        final var child2 = dataTreeCandidateNode(childNode, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DELETE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testUnmodifiedWrite() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
+    void testUnmodifiedWrite() {
+        final var parentNode1 = normalizedNode("container1");
+        final var childNode1 = normalizedNode("child1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testUnmodifiedSubtreeModifiedWithoutDataBefore() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testUnmodifiedSubtreeModifiedWithoutDataBefore() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(null, null, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, parentNode, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode, parentNode, SUBTREE_MODIFIED);
+        final var child2 = dataTreeCandidateNode(null, childNode, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
@@ -350,43 +350,43 @@ public class DataTreeCandidatesAggregateTest {
 
     //FIXME
     @Test
-    public void testUnmodifiedSubtreeModified() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode parentNode2 = normalizedNode("container1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
+    void testUnmodifiedSubtreeModified() {
+        final var parentNode1 = normalizedNode("container1");
+        final var childNode1 = normalizedNode("child1");
+        final var parentNode2 = normalizedNode("container1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(SUBTREE_MODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testUnmodifiedAppearedWithDataBefore() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode parentNode2 = normalizedNode("container1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
+    void testUnmodifiedAppearedWithDataBefore() {
+        final var parentNode1 = normalizedNode("container1");
+        final var childNode1 = normalizedNode("child1");
+        final var parentNode2 = normalizedNode("container1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, APPEARED);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
@@ -394,678 +394,678 @@ public class DataTreeCandidatesAggregateTest {
 
     //FIXME
     @Test
-    public void testUnmodifiedAppeared() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testUnmodifiedAppeared() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(null, null, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, parentNode, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode, parentNode, APPEARED);
+        final var child2 = dataTreeCandidateNode(null, childNode, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(APPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testUnmodifiedDisappearWithoutDataBefore() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testUnmodifiedDisappearWithoutDataBefore() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var node1 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(null, null, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, parentNode, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode, parentNode, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(null, childNode, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testUnmodifiedDisappear() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testUnmodifiedDisappear() {
+        final var parentNode1 = normalizedNode("container1");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DISAPPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDeleteUnmodified() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testDeleteUnmodified() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode, null, DELETE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, null, DELETE);
+        final var node1 = dataTreeCandidateNode(parentNode, null, DELETE);
+        final var child1 = dataTreeCandidateNode(childNode, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var node2 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var child2 = dataTreeCandidateNode(null, null, UNMODIFIED);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DELETE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDeleteWrite() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DELETE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+    void testDeleteWrite() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DELETE);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(null, parentNode2, WRITE);
+        final var child2 = dataTreeCandidateNode(null, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDeleteAppear() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DELETE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+    void testDeleteAppear() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DELETE);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, parentNode2, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(null, parentNode2, APPEARED);
+        final var child2 = dataTreeCandidateNode(null, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteUnmodified() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testWriteUnmodified() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode, WRITE);
+        final var child1 = dataTreeCandidateNode(null, childNode, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
+        final var node2 = dataTreeCandidateNode(parentNode, parentNode, UNMODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode, childNode, UNMODIFIED);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteDeleteWithoutChanges() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testWriteDeleteWithoutChanges() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode, WRITE);
+        final var child1 = dataTreeCandidateNode(null, childNode, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, null, DELETE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode, null, DELETE);
+        final var child2 = dataTreeCandidateNode(childNode, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteDelete() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+    void testWriteDelete() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode2, null, DELETE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode2, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode2, null, DELETE);
+        final var child2 = dataTreeCandidateNode(childNode2, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DELETE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteWrite() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+    void testWriteWrite() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(null, parentNode1, WRITE);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteSubtreeModified() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container1");
-        NormalizedNode childNode = normalizedNode("child");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode, parentNode1, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
+    void testWriteSubtreeModified() {
+        final var parentNode = normalizedNode("container");
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container1");
+        final var childNode = normalizedNode("child");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode, parentNode1, WRITE);
+        final var child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteAppear() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-        NormalizedNode childNode3 = normalizedNode("child3");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+    void testWriteAppear() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+        final var childNode3 = normalizedNode("child3");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode2, parentNode2, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode2, childNode3, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode2, parentNode2, APPEARED);
+        final var child2 = dataTreeCandidateNode(childNode2, childNode3, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testWriteDisappearWithoutChanges() {
-        NormalizedNode parentNode = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("child");
+    void testWriteDisappearWithoutChanges() {
+        final var parentNode = normalizedNode("container");
+        final var childNode = normalizedNode("child");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode, WRITE);
+        final var child1 = dataTreeCandidateNode(null, childNode, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode, null, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(childNode, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testWriteDisappear() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+    void testWriteDisappear() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode2, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode2, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode2, null, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(childNode2, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DISAPPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testSubtreeModifiedUnmodified() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container1");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+    void testSubtreeModifiedUnmodified() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container1");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode2, parentNode2, UNMODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode2, childNode2, UNMODIFIED);
+        final var node2 = dataTreeCandidateNode(parentNode2, parentNode2, UNMODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode2, childNode2, UNMODIFIED);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(SUBTREE_MODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testSubtreeModifiedDelete() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container1");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+    void testSubtreeModifiedDelete() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container1");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode2, SUBTREE_MODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode2, null, DELETE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode2, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode2, null, DELETE);
+        final var child2 = dataTreeCandidateNode(childNode2, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DELETE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testSubtreeModifiedWrite() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode parentNode2 = normalizedNode("value2");
-        NormalizedNode childNode = normalizedNode("childNode");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
+    void testSubtreeModifiedWrite() {
+        final var parentNode1 = normalizedNode("container");
+        final var parentNode2 = normalizedNode("value2");
+        final var childNode = normalizedNode("childNode");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testSubtreeModifiedSubtreeModified() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("childNode");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
+    void testSubtreeModifiedSubtreeModified() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode = normalizedNode("childNode");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(SUBTREE_MODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testSubtreeModifiedAppear() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode parentNode2 = normalizedNode("value2");
-        NormalizedNode childNode = normalizedNode("childNode");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
+    void testSubtreeModifiedAppear() {
+        final var parentNode1 = normalizedNode("container");
+        final var parentNode2 = normalizedNode("value2");
+        final var childNode = normalizedNode("childNode");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, parentNode2, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(null, parentNode2, APPEARED);
+        final var child2 = dataTreeCandidateNode(null, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testSubtreeModifiedDisappear() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode = normalizedNode("childNode");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testSubtreeModifiedDisappear() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode = normalizedNode("childNode");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
+        final var node1 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
+        final var child1 = dataTreeCandidateNode(childNode, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DISAPPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testAppearedUnmodified() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testAppearedUnmodified() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode1, UNMODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode1, UNMODIFIED);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(APPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testAppearedDelete() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testAppearedDelete() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, null, DELETE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode1, null, DELETE);
+        final var child2 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testAppearedWriteWithoutChanges() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode parentNode2 = normalizedNode("value2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+    void testAppearedWriteWithoutChanges() {
+        final var parentNode1 = normalizedNode("container");
+        final var parentNode2 = normalizedNode("value2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode2, WRITE);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testAppearedSubtreeModified() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
+    void testAppearedSubtreeModified() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(parentNode1, parentNode1, SUBTREE_MODIFIED);
+        final var child2 = dataTreeCandidateNode(childNode1, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(APPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testAppearedAppeared() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testAppearedAppeared() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode1, WRITE);
+        final var node2 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child2 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testAppearedDisappeared() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testAppearedDisappeared() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(null, childNode1, WRITE);
+        final var node1 = dataTreeCandidateNode(null, parentNode1, APPEARED);
+        final var child1 = dataTreeCandidateNode(null, childNode1, WRITE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node2 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(UNMODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDisappearedUnmodified() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testDisappearedUnmodified() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, UNMODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var node2 = dataTreeCandidateNode(null, null, UNMODIFIED);
+        final var child2 = dataTreeCandidateNode(null, null, UNMODIFIED);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(DISAPPEARED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDisappearedDelete() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testDisappearedDelete() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, DELETE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, null, DELETE);
+        final var node2 = dataTreeCandidateNode(null, null, DELETE);
+        final var child2 = dataTreeCandidateNode(null, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testDisappearedWrite() {
-        NormalizedNode parentNode1 = normalizedNode("container1");
-        NormalizedNode parentNode2 = normalizedNode("container2");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+    void testDisappearedWrite() {
+        final var parentNode1 = normalizedNode("container1");
+        final var parentNode2 = normalizedNode("container2");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, parentNode2, WRITE);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(null, parentNode2, WRITE);
+        final var child2 = dataTreeCandidateNode(null, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(WRITE, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDisappearedSubtreeModified() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
+    void testDisappearedSubtreeModified() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, SUBTREE_MODIFIED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(null, null, SUBTREE_MODIFIED);
+        final var child2 = dataTreeCandidateNode(null, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     @Test
-    public void testDisappearedAppeared() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode parentNode2 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
-        NormalizedNode childNode2 = normalizedNode("child2");
-
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+    void testDisappearedAppeared() {
+        final var parentNode1 = normalizedNode("container");
+        final var parentNode2 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
+        final var childNode2 = normalizedNode("child2");
+
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, parentNode2, APPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, childNode2, WRITE);
+        final var node2 = dataTreeCandidateNode(null, parentNode2, APPEARED);
+        final var child2 = dataTreeCandidateNode(null, childNode2, WRITE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
-        DataTreeCandidate aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
+        final var aggregationResult = DataTreeCandidates.aggregate(List.of(candidate1, candidate2));
 
         assertEquals(SUBTREE_MODIFIED, aggregationResult.getRootNode().modificationType());
     }
 
     @Test
-    public void testDisappearedDisappear() {
-        NormalizedNode parentNode1 = normalizedNode("container");
-        NormalizedNode childNode1 = normalizedNode("child1");
+    void testDisappearedDisappear() {
+        final var parentNode1 = normalizedNode("container");
+        final var childNode1 = normalizedNode("child1");
 
-        TerminalDataTreeCandidateNode node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child1 = dataTreeCandidateNode(childNode1, null, DELETE);
+        final var node1 = dataTreeCandidateNode(parentNode1, null, DISAPPEARED);
+        final var child1 = dataTreeCandidateNode(childNode1, null, DELETE);
         setChildNodes(node1, List.of(child1));
-        DataTreeCandidate candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
+        final var candidate1 = new DefaultDataTreeCandidate(ROOT_PATH, node1);
 
-        TerminalDataTreeCandidateNode node2 = dataTreeCandidateNode(null, null, DISAPPEARED);
-        TerminalDataTreeCandidateNode child2 = dataTreeCandidateNode(null, null, DELETE);
+        final var node2 = dataTreeCandidateNode(null, null, DISAPPEARED);
+        final var child2 = dataTreeCandidateNode(null, null, DELETE);
         setChildNodes(node2, List.of(child2));
-        DataTreeCandidate candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
+        final var candidate2 = new DefaultDataTreeCandidate(ROOT_PATH, node2);
 
         assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.aggregate(List.of(candidate1, candidate2)));
     }
 
     private static LeafNode<String> normalizedNode(final String value) {
-        LeafNode<String> node = mock(LeafNode.class);
+        final var node = mock(LeafNode.class);
         doReturn(value).when(node).body();
         return node;
     }
@@ -1073,7 +1073,7 @@ public class DataTreeCandidatesAggregateTest {
     private static TerminalDataTreeCandidateNode dataTreeCandidateNode(final NormalizedNode before,
                                                                        final NormalizedNode after,
                                                                        final ModificationType modification) {
-        TerminalDataTreeCandidateNode dataTreeCandidateNode = mock(TerminalDataTreeCandidateNode.class);
+        final var dataTreeCandidateNode = mock(TerminalDataTreeCandidateNode.class);
         doReturn(null).when(dataTreeCandidateNode).name();
         doReturn(before).when(dataTreeCandidateNode).dataBefore();
         doReturn(after).when(dataTreeCandidateNode).dataAfter();

diff --git a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesTest.java b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesTest.java
index f69b546c190c45e98fbba8997d6d85b397d66247..09bdc2b0cbf8a996e6874df52614fb0f8388c230 100644 (file)
--- a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesTest.java
+++ b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeCandidatesTest.java
@@ -7,12 +7,11 @@
  */
 package org.opendaylight.yangtools.yang.data.tree.spi;
 
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.doReturn;
@@ -22,9 +21,7 @@ import static org.mockito.Mockito.verify;
 
 import java.util.List;
 import java.util.Optional;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@@ -36,40 +33,39 @@ import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModificationCursor;
 import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
 
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class DataTreeCandidatesTest {
+class DataTreeCandidatesTest {
     private static final NodeIdentifier FOO = new NodeIdentifier(QName.create("foo", "foo"));
 
     @Test
-    public void testNewDataTreeCandidate() {
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
-        final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.newDataTreeCandidate(
+    void testNewDataTreeCandidate() {
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var dataTreeCandidate = DataTreeCandidates.newDataTreeCandidate(
             YangInstanceIdentifier.of(), mockedDataTreeCandidateNode);
 
-        assertThat(dataTreeCandidate, instanceOf(DefaultDataTreeCandidate.class));
+        assertInstanceOf(DefaultDataTreeCandidate.class, dataTreeCandidate);
         assertSame(YangInstanceIdentifier.of(), dataTreeCandidate.getRootPath());
         assertEquals(mockedDataTreeCandidateNode, dataTreeCandidate.getRootNode());
-        assertThat(dataTreeCandidate.toString(),
-            containsString("DefaultDataTreeCandidate{rootPath=/, rootNode=Mock for DataTreeCandidateNode, hashCode: "));
+        assertTrue(dataTreeCandidate.toString()
+                .contains("DefaultDataTreeCandidate{rootPath=/, rootNode=Mock for DataTreeCandidateNode, hashCode: "));
     }
 
     @Test
-    public void testFromNormalizedNode() {
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
-        final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.fromNormalizedNode(
+    void testFromNormalizedNode() {
+        final var mockedNormalizedNode = mock(NormalizedNode.class);
+        final var dataTreeCandidate = DataTreeCandidates.fromNormalizedNode(
             YangInstanceIdentifier.of(), mockedNormalizedNode);
 
-        assertThat(dataTreeCandidate, instanceOf(DefaultDataTreeCandidate.class));
+        assertInstanceOf(DefaultDataTreeCandidate.class, dataTreeCandidate);
         assertSame(YangInstanceIdentifier.of(), dataTreeCandidate.getRootPath());
-        assertThat(dataTreeCandidate.getRootNode(), instanceOf(NormalizedNodeDataTreeCandidateNode.class));
+        assertInstanceOf(NormalizedNodeDataTreeCandidateNode.class, dataTreeCandidate.getRootNode());
     }
 
     @Test
-    public void testApplyToCursor() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+    void testApplyToCursor() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
 
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).modificationType();
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
         DataTreeCandidates.applyToCursor(mockedCursor, mockedDataTreeCandidate);
@@ -77,15 +73,15 @@ public class DataTreeCandidatesTest {
     }
 
     @Test
-    public void testApplyToCursorAwareModification() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final CursorAwareDataTreeModification mockedModification = mock(CursorAwareDataTreeModification.class);
+    void testApplyToCursorAwareModification() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedModification = mock(CursorAwareDataTreeModification.class);
 
         doReturn(YangInstanceIdentifier.of(FOO)).when(mockedDataTreeCandidate).getRootPath();
 
-        final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+        final var mockedCursor = mock(DataTreeModificationCursor.class);
         doReturn(Optional.of(mockedCursor)).when(mockedModification).openCursor(YangInstanceIdentifier.of());
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
 
         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).modificationType();
@@ -96,10 +92,10 @@ public class DataTreeCandidatesTest {
     }
 
     @Test
-    public void testApplyToCursorAwareModificationRoot() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final CursorAwareDataTreeModification mockedModification = mock(CursorAwareDataTreeModification.class);
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+    void testApplyToCursorAwareModificationRoot() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedModification = mock(CursorAwareDataTreeModification.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).modificationType();
@@ -110,11 +106,11 @@ public class DataTreeCandidatesTest {
     }
 
     @Test
-    public void testApplyToModificationWithDeleteModificationType() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final DataTreeModification mockedModification = mock(DataTreeModification.class);
+    void testApplyToModificationWithDeleteModificationType() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedModification = mock(DataTreeModification.class);
 
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
         doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
 
@@ -125,14 +121,14 @@ public class DataTreeCandidatesTest {
     }
 
     @Test
-    public void testApplyToModificationWithWriteModificationType() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final DataTreeModification mockedModification = mock(DataTreeModification.class);
+    void testApplyToModificationWithWriteModificationType() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedModification = mock(DataTreeModification.class);
 
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
         doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
+        final var mockedNormalizedNode = mock(NormalizedNode.class);
         doReturn(mockedNormalizedNode).when(mockedDataTreeCandidateNode).dataAfter();
 
         doReturn(ModificationType.WRITE).when(mockedDataTreeCandidateNode).modificationType();
@@ -142,35 +138,35 @@ public class DataTreeCandidatesTest {
     }
 
     @Test
-    public void testApplyToModificationWithSubtreeModifiedModificationType() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final DataTreeModification mockedModification = mock(DataTreeModification.class);
+    void testApplyToModificationWithSubtreeModifiedModificationType() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedModification = mock(DataTreeModification.class);
 
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
         doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
 
         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).modificationType();
 
-        final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode1 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedChildNode1).modificationType();
         doReturn(new NodeIdentifier(QName.create("test", "test1"))).when(mockedChildNode1).name();
 
-        final DataTreeCandidateNode mockedChildNode2 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode2 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.WRITE).when(mockedChildNode2).modificationType();
         final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
         doReturn(mockedNormalizedNode).when(mockedChildNode2).dataAfter();
         doReturn(new NodeIdentifier(QName.create("test", "test2"))).when(mockedChildNode2).name();
 
-        final DataTreeCandidateNode mockedChildNode3 = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode3 = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedChildNode3).modificationType();
-        final DataTreeCandidateNode mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
+        final var mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
         doReturn(ModificationType.DELETE).when(mockedChildNode3ChildNode).modificationType();
         doReturn(new NodeIdentifier(QName.create("test", "test3"))).when(mockedChildNode3).name();
         doReturn(new NodeIdentifier(QName.create("test", "test4"))).when(mockedChildNode3ChildNode).name();
         doReturn(List.of(mockedChildNode3ChildNode)).when(mockedChildNode3).childNodes();
 
-        final List<DataTreeCandidateNode> childNodes = List.of(mockedChildNode1, mockedChildNode2, mockedChildNode3);
+        final var childNodes = List.of(mockedChildNode1, mockedChildNode2, mockedChildNode3);
         doReturn(childNodes).when(mockedDataTreeCandidateNode).childNodes();
 
         DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
@@ -179,18 +175,18 @@ public class DataTreeCandidatesTest {
     }
 
     @Test
-    public void testApplyToModificationWithUnsupportedModificationType() {
-        final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
-        final DataTreeModification mockedModification = mock(DataTreeModification.class);
+    void testApplyToModificationWithUnsupportedModificationType() {
+        final var mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+        final var mockedModification = mock(DataTreeModification.class);
 
-        final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+        final var mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
         doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
 
         doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).modificationType();
 
-        final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+        final var ex = assertThrows(IllegalArgumentException.class,
             () -> DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate));
-        assertThat(ex.getMessage(), containsString("Unsupported modification"));
+        assertTrue(ex.getMessage().contains("Unsupported modification"));
     }
 }

diff --git a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeConfigurationTest.java b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeConfigurationTest.java
index 3278b418f03f5a2a587c31e3db57e8c475714cc5..781d6ec3a1eb4a8e9e8a6e55e0ac7b7d98cf45b1 100644 (file)
--- a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeConfigurationTest.java
+++ b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/DataTreeConfigurationTest.java
@@ -7,22 +7,22 @@
  */
 package org.opendaylight.yangtools.yang.data.tree.spi;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
 import org.opendaylight.yangtools.yang.data.tree.api.TreeType;
 
-public class DataTreeConfigurationTest {
+class DataTreeConfigurationTest {
     @Test
-    public void testDataTreeConfiguration() {
-        DataTreeConfiguration.Builder builder = new DataTreeConfiguration.Builder(TreeType.CONFIGURATION);
+    void testDataTreeConfiguration() {
+        var builder = new DataTreeConfiguration.Builder(TreeType.CONFIGURATION);
         builder.setUniqueIndexes(true);
         builder.setMandatoryNodesValidation(true);
 
-        DataTreeConfiguration dataTreeConfiguration = builder.build();
+        var dataTreeConfiguration = builder.build();
         assertEquals(TreeType.CONFIGURATION, dataTreeConfiguration.getTreeType());
         assertTrue(dataTreeConfiguration.isUniqueIndexEnabled());
         assertTrue(dataTreeConfiguration.isMandatoryNodesValidationEnabled());

diff --git a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/NormalizedNodeDataTreeCandidateNodeTest.java b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/NormalizedNodeDataTreeCandidateNodeTest.java
index 2cfbc9794401c0f26c674a913bc8b18f19fea2ba..2403fb1358784b2eb49dacac935c1bbc7a2a5e4e 100644 (file)
--- a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/NormalizedNodeDataTreeCandidateNodeTest.java
+++ b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/NormalizedNodeDataTreeCandidateNodeTest.java
@@ -7,54 +7,53 @@
  */
 package org.opendaylight.yangtools.yang.data.tree.spi;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.List;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
 import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
 
-public class NormalizedNodeDataTreeCandidateNodeTest {
+class NormalizedNodeDataTreeCandidateNodeTest {
     @Test
-    public void testNormalizedNodeDataTreeCandidateNode() {
-        final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
-        final NormalizedNodeDataTreeCandidateNode normalizedNodeDataTreeCandidateNode = new
+    void testNormalizedNodeDataTreeCandidateNode() {
+        final var mockedNormalizedNode = mock(NormalizedNode.class);
+        final var normalizedNodeDataTreeCandidateNode = new
                 NormalizedNodeDataTreeCandidateNode(mockedNormalizedNode);
 
         final var mockedPathArgument = new NodeIdentifier(QName.create("test", "test"));
         doReturn(mockedPathArgument).when(mockedNormalizedNode).name();
         assertSame(mockedPathArgument, normalizedNodeDataTreeCandidateNode.name());
 
-        final Collection<DataTreeCandidateNode> childNodes = normalizedNodeDataTreeCandidateNode.childNodes();
-        assertTrue(childNodes instanceof List);
+        final var childNodes = normalizedNodeDataTreeCandidateNode.childNodes();
+        assertInstanceOf(List.class, childNodes);
         assertTrue(childNodes.isEmpty());
 
         assertNull(normalizedNodeDataTreeCandidateNode.modifiedChild(mockedPathArgument));
 
         assertEquals(ModificationType.WRITE, normalizedNodeDataTreeCandidateNode.modificationType());
         assertEquals(mockedNormalizedNode, normalizedNodeDataTreeCandidateNode.dataAfter());
-        assertEquals(null, normalizedNodeDataTreeCandidateNode.dataBefore());
+        assertNull(normalizedNodeDataTreeCandidateNode.dataBefore());
 
-        final DistinctNodeContainer mockedNormalizedNodeContainer = mock(DistinctNodeContainer.class);
-        final NormalizedNodeDataTreeCandidateNode normalizedNodeDataTreeCandidateNode2 = new
+        final var mockedNormalizedNodeContainer = mock(DistinctNodeContainer.class);
+        final var normalizedNodeDataTreeCandidateNode2 = new
                 NormalizedNodeDataTreeCandidateNode(mockedNormalizedNodeContainer);
-        final NormalizedNode mockedChildNormNode1 = mock(NormalizedNode.class);
-        final NormalizedNode mockedChildNormNode2 = mock(NormalizedNode.class);
+        final var mockedChildNormNode1 = mock(NormalizedNode.class);
+        final var mockedChildNormNode2 = mock(NormalizedNode.class);
         final var mockedChildNodes = Arrays.asList(mockedChildNormNode1, mockedChildNormNode2, null);
         doReturn(mockedChildNodes).when(mockedNormalizedNodeContainer).body();
         final var childNodes2 = normalizedNodeDataTreeCandidateNode2.childNodes();

diff --git a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/YT1455Test.java b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/YT1455Test.java
index ffb475d942d9d3044541f6e0ab9fac2d622b61c7..2a2aa3464c92aba680060c376826a2c01555696c 100644 (file)
--- a/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/YT1455Test.java
+++ b/data/yang-data-tree-spi/src/test/java/org/opendaylight/yangtools/yang/data/tree/spi/YT1455Test.java
@@ -7,14 +7,15 @@
  */
 package org.opendaylight.yangtools.yang.data.tree.spi;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.mockito.Mockito.doReturn;
 
 import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@@ -23,8 +24,8 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
 import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
 
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class YT1455Test {
+@ExtendWith(MockitoExtension.class)
+class YT1455Test {
     @Mock
     public DistinctNodeContainer<PathArgument, NormalizedNode> oldData;
     @Mock
@@ -33,7 +34,7 @@ public class YT1455Test {
     public UnkeyedListNode child;
 
     @Test
-    public void testDeleteUnkeyedList() {
+    void testDeleteUnkeyedList() {
         final var childId = new NodeIdentifier(QName.create("foo", "foo"));
         doReturn(childId).when(child).name();
         doReturn(List.of(child)).when(oldData).body();
@@ -47,7 +48,7 @@ public class YT1455Test {
         assertEquals(childId, first.name());
         assertEquals(ModificationType.DELETE, first.modificationType());
         assertEquals(child, first.dataBefore());
-        assertEquals(null, first.dataAfter());
+        assertNull(first.dataAfter());
         assertEquals(0, first.childNodes().size());
     }
 }