Migrate yang-data-api to JUnit5

We have a few tests here, migrate them over.

Change-Id: I56dd6bbeda75a9225644aacb242ecc46a88878f0
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/PathArgumentListTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/PathArgumentListTest.java
index 5f5f79508f68d1c0783e06e863ee300afa486886..adc0a62ee016b4caf31d60f4842a3591d12081f4 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/PathArgumentListTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/PathArgumentListTest.java
@@ -7,18 +7,18 @@
  */
 package org.opendaylight.yangtools.yang.data.api;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThrows;
-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.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.google.common.collect.UnmodifiableIterator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.Revision;

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifierTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifierTest.java
index 0b19109e7c4821288c201a7a3fe711e54f1f9bb5..aacb13d3e7bf289e533f5b5a68614b0007f6301d 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifierTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/YangInstanceIdentifierTest.java
@@ -7,15 +7,14 @@
  */
 package org.opendaylight.yangtools.yang.data.api;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThrows;
-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.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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.google.common.collect.ImmutableSet;
 import java.io.ByteArrayInputStream;
@@ -28,7 +27,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
-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.AugmentationIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@@ -42,7 +41,6 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgum
  * @author Thomas Pantelis
  */
 public class YangInstanceIdentifierTest {
-
     private static final QName NODENAME1 = QName.create("test", "2014-05-28", "node1");
     private static final QName NODENAME2 = QName.create("test", "2014-05-28", "node2");
     private static final QName NODENAME3 = QName.create("test", "2014-05-28", "node3");
@@ -55,7 +53,7 @@ public class YangInstanceIdentifierTest {
     public void testGetLastPathArgument() {
         YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
                 new NodeIdentifier(NODENAME2));
-        assertEquals("getLastPathArgument", new NodeIdentifier(NODENAME2), id1.getLastPathArgument());
+        assertEquals(new NodeIdentifier(NODENAME2), id1.getLastPathArgument());
         YangInstanceIdentifier id2 = YangInstanceIdentifier.create();
         assertNull(id2.getLastPathArgument());
     }
@@ -66,8 +64,7 @@ public class YangInstanceIdentifierTest {
                 new NodeIdentifier(NODENAME2));
         YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
                 NodeIdentifier.create(NODENAME2));
-
-        assertEquals("hashCode", id1.hashCode(), id2.hashCode());
+        assertEquals(id1.hashCode(), id2.hashCode());
     }
 
     @Test
@@ -80,12 +77,12 @@ public class YangInstanceIdentifierTest {
                 new NodeIdentifier(NODENAME1));
         final YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
 
-        assertFalse("equals", id1.equals(null));
-        assertTrue("equals", id1.equals(id1));
-        assertTrue("equals", id1.equals(id2));
-        assertFalse("equals", id1.equals(id3));
-        assertFalse("equals", id1.equals(id4));
-        assertFalse("equals", id1.equals(new Object()));
+        assertFalse(id1.equals(null));
+        assertTrue(id1.equals(id1));
+        assertTrue(id1.equals(id2));
+        assertFalse(id1.equals(id3));
+        assertFalse(id1.equals(id4));
+        assertFalse(id1.equals(new Object()));
     }
 
     @Test
@@ -102,24 +99,22 @@ public class YangInstanceIdentifierTest {
                 new NodeIdentifier(NODENAME2));
 
         YangInstanceIdentifier newID = id.node(NODENAME3);
-
-        assertNotNull("InstanceIdentifier is null", newID);
-        assertEquals("Path size", 3, newID.getPathArguments().size());
+        assertNotNull(newID);
+        assertEquals(3, newID.getPathArguments().size());
 
         Iterator<PathArgument> it = newID.getPathArguments().iterator();
-        assertEquals("PathArg 1 node type", NODENAME1, it.next().getNodeType());
-        assertEquals("PathArg 2 node type", NODENAME2, it.next().getNodeType());
-        assertEquals("PathArg 3 node type", NODENAME3, it.next().getNodeType());
+        assertEquals(NODENAME1, it.next().getNodeType());
+        assertEquals(NODENAME2, it.next().getNodeType());
+        assertEquals(NODENAME3, it.next().getNodeType());
 
         newID = id.node(new NodeIdentifier(NODENAME3));
-
-        assertNotNull("InstanceIdentifier is null", newID);
-        assertEquals("Path size", 3, newID.getPathArguments().size());
+        assertNotNull(newID);
+        assertEquals(3, newID.getPathArguments().size());
 
         it = newID.getPathArguments().iterator();
-        assertEquals("PathArg 1 node type", NODENAME1, it.next().getNodeType());
-        assertEquals("PathArg 2 node type", NODENAME2, it.next().getNodeType());
-        assertEquals("PathArg 3 node type", NODENAME3, it.next().getNodeType());
+        assertEquals(NODENAME1, it.next().getNodeType());
+        assertEquals(NODENAME2, it.next().getNodeType());
+        assertEquals(NODENAME3, it.next().getNodeType());
     }
 
     @Test
@@ -132,19 +127,19 @@ public class YangInstanceIdentifierTest {
                     new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2)));
 
         Optional<YangInstanceIdentifier> relative = id1.relativeTo(id2);
-        assertTrue("isPresent", relative.isPresent());
+        assertTrue(relative.isPresent());
 
         List<PathArgument> path = relative.get().getPathArguments();
-        assertEquals("Path size", 2, path.size());
-        assertEquals("PathArg 1 node type", NODENAME3, path.get(0).getNodeType());
-        assertEquals("PathArg 2 node type", NODENAME4, path.get(1).getNodeType());
+        assertEquals(2, path.size());
+        assertEquals(NODENAME3, path.get(0).getNodeType());
+        assertEquals(NODENAME4, path.get(1).getNodeType());
 
         relative = id2.relativeTo(id3);
-        assertTrue("isPresent", relative.isPresent());
-        assertEquals("Path size", 0, relative.get().getPathArguments().size());
+        assertTrue(relative.isPresent());
+        assertEquals(0, relative.get().getPathArguments().size());
 
         relative = id2.relativeTo(id1);
-        assertFalse("isPresent", relative.isPresent());
+        assertFalse(relative.isPresent());
     }
 
     @Test
@@ -165,19 +160,18 @@ public class YangInstanceIdentifierTest {
         final YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
                 new NodeIdentifier(NODENAME3));
 
-        assertTrue("contains", id2.contains(id1));
-        assertTrue("contains", id2.contains(id3));
-        assertFalse("contains", id1.contains(id2));
-        assertFalse("contains", id2.contains(id4));
+        assertTrue(id2.contains(id1));
+        assertTrue(id2.contains(id3));
+        assertFalse(id1.contains(id2));
+        assertFalse(id2.contains(id4));
     }
 
     @Test
     public void testOf() {
         YangInstanceIdentifier newID = YangInstanceIdentifier.of(NODENAME1);
-
-        assertNotNull("InstanceIdentifier is null", newID);
-        assertEquals("Path size", 1, newID.getPathArguments().size());
-        assertEquals("PathArg 1 node type", NODENAME1, newID.getPathArguments().get(0).getNodeType());
+        assertNotNull(newID);
+        assertEquals(1, newID.getPathArguments().size());
+        assertEquals(NODENAME1, newID.getPathArguments().get(0).getNodeType());
 
         // for code coverage
         assertNotNull(newID.toString());
@@ -190,43 +184,43 @@ public class YangInstanceIdentifierTest {
                 .nodeWithKey(NODENAME2, Map.of(KEY1, "foo"))
                 .nodeWithKey(NODENAME3, KEY2, "bar").build();
 
-        assertNotNull("InstanceIdentifier is null", newID);
-        assertEquals("Path size", 3, newID.getPathArguments().size());
+        assertNotNull(newID);
+        assertEquals(3, newID.getPathArguments().size());
 
         Iterator<PathArgument> it = newID.getPathArguments().iterator();
-        assertEquals("PathArg 1 node type", NODENAME1, it.next().getNodeType());
+        assertEquals(NODENAME1, it.next().getNodeType());
         verifyNodeIdentifierWithPredicates("PathArg 2", it.next(), NODENAME2, KEY1, "foo");
         verifyNodeIdentifierWithPredicates("PathArg 3", it.next(), NODENAME3, KEY2, "bar");
 
         newID = YangInstanceIdentifier.builder(newID).node(NODENAME4).build();
 
-        assertNotNull("InstanceIdentifier is null", newID);
-        assertEquals("Path size", 4, newID.getPathArguments().size());
+        assertNotNull(newID);
+        assertEquals(4, newID.getPathArguments().size());
 
         it = newID.getPathArguments().iterator();
-        assertEquals("PathArg 1 node type", NODENAME1, it.next().getNodeType());
-        assertEquals("PathArg 2 node type", NODENAME2, it.next().getNodeType());
-        assertEquals("PathArg 3 node type", NODENAME3, it.next().getNodeType());
-        assertEquals("PathArg 4 node type", NODENAME4, it.next().getNodeType());
+        assertEquals(NODENAME1, it.next().getNodeType());
+        assertEquals(NODENAME2, it.next().getNodeType());
+        assertEquals(NODENAME3, it.next().getNodeType());
+        assertEquals(NODENAME4, it.next().getNodeType());
 
         newID = YangInstanceIdentifier.builder().node(NODENAME1).build();
 
-        assertNotNull("InstanceIdentifier is null", newID);
-        assertEquals("Path size", 1, newID.getPathArguments().size());
-        assertEquals("PathArg 1 node type", NODENAME1, newID.getPathArguments().get(0).getNodeType());
+        assertNotNull(newID);
+        assertEquals(1, newID.getPathArguments().size());
+        assertEquals(NODENAME1, newID.getPathArguments().get(0).getNodeType());
     }
 
     private static void verifyNodeIdentifierWithPredicates(final String prefix,
             final PathArgument arg, final QName nodeName, final QName key, final Object value) {
 
-        assertNotNull(prefix + " is null", arg);
-        assertThat(arg, instanceOf(NodeIdentifierWithPredicates.class));
+        assertNotNull(arg, prefix + " is null");
+        assertInstanceOf(NodeIdentifierWithPredicates.class, arg);
         NodeIdentifierWithPredicates node = (NodeIdentifierWithPredicates)arg;
-        assertEquals(prefix + " node type", nodeName, node.getNodeType());
-        assertEquals(prefix + " key values map size", 1, node.size());
+        assertEquals(nodeName, node.getNodeType(), prefix + " node type");
+        assertEquals(1, node.size(), prefix + " key values map size");
         Entry<QName, Object> entry = node.entrySet().iterator().next();
-        assertEquals(prefix + " key values map entry key", key, entry.getKey());
-        assertEquals(prefix + " key values map entry value", value, entry.getValue());
+        assertEquals(key, entry.getKey(), prefix + " key values map entry key");
+        assertEquals(value, entry.getValue(), prefix + " key values map entry value");
     }
 
     @Test
@@ -237,13 +231,13 @@ public class YangInstanceIdentifierTest {
 
         NodeIdentifierWithPredicates node2 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "foo");
 
-        assertEquals("hashCode", node1.hashCode(), node2.hashCode());
-        assertTrue("equals", node1.equals(node2));
+        assertEquals(node1.hashCode(), node2.hashCode());
+        assertTrue(node1.equals(node2));
 
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME2, KEY1, "foo")));
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY2, "foo")));
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "bar")));
-        assertFalse("equals", node1.equals(new Object()));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME2, KEY1, "foo")));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY2, "foo")));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "bar")));
+        assertFalse(node1.equals(new Object()));
 
         // for code coverage
         assertNotNull(node1.toString());
@@ -253,38 +247,38 @@ public class YangInstanceIdentifierTest {
 
         NodeIdentifierWithPredicates node4 = NodeIdentifierWithPredicates.of(NODENAME1, Map.of(KEY1, 10, KEY2, 20));
 
-        assertEquals("hashCode", node3.hashCode(), node4.hashCode());
-        assertTrue("equals", node3.equals(node4));
+        assertEquals(node3.hashCode(), node4.hashCode());
+        assertTrue(node3.equals(node4));
 
-        assertFalse("equals", node3.equals(node1));
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, Map.of(KEY1, 10, KEY3, 20))));
+        assertFalse(node3.equals(node1));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, Map.of(KEY1, 10, KEY3, 20))));
 
         node1 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2 });
         node2 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2 });
 
-        assertEquals("hashCode", node1.hashCode(), node2.hashCode());
-        assertTrue("equals", node1.equals(node2));
+        assertEquals(node1.hashCode(), node2.hashCode());
+        assertTrue(node1.equals(node2));
 
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 3})));
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1 })));
-        assertFalse("equals", node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2, 3 })));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 3})));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1 })));
+        assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2, 3 })));
     }
 
     @Test
     public void testNodeWithValue() {
 
         NodeWithValue<?> node1 = new NodeWithValue<>(NODENAME1, "foo");
-        assertEquals("getNodeType", NODENAME1, node1.getNodeType());
-        assertEquals("getValue", "foo", node1.getValue());
+        assertEquals(NODENAME1, node1.getNodeType());
+        assertEquals("foo", node1.getValue());
 
         NodeWithValue<?> node2 = new NodeWithValue<>(NODENAME1, "foo");
 
-        assertEquals("hashCode", node1.hashCode(), node2.hashCode());
-        assertTrue("equals", node1.equals(node2));
+        assertEquals(node1.hashCode(), node2.hashCode());
+        assertTrue(node1.equals(node2));
 
-        assertFalse("equals", node1.equals(new NodeWithValue<>(NODENAME1, "bar")));
-        assertFalse("equals", node1.equals(new NodeWithValue<>(NODENAME2, "foo")));
-        assertFalse("equals", node1.equals(new Object()));
+        assertFalse(node1.equals(new NodeWithValue<>(NODENAME1, "bar")));
+        assertFalse(node1.equals(new NodeWithValue<>(NODENAME2, "foo")));
+        assertFalse(node1.equals(new Object()));
 
         // for code coverage
         assertNotNull(node1.toString());
@@ -293,31 +287,31 @@ public class YangInstanceIdentifierTest {
         NodeWithValue<?> node3 = new NodeWithValue<>(NODENAME1, new byte[]{1,2});
         NodeWithValue<?> node4 = new NodeWithValue<>(NODENAME1, new byte[]{1,2});
 
-        assertEquals("hashCode", node3.hashCode(), node4.hashCode());
-        assertTrue("equals", node3.equals(node4));
+        assertEquals(node3.hashCode(), node4.hashCode());
+        assertTrue(node3.equals(node4));
 
-        assertFalse("equals", node3.equals(new NodeWithValue<>(NODENAME1, new byte[]{1,3})));
-        assertFalse("equals", node3.equals(node1));
+        assertFalse(node3.equals(new NodeWithValue<>(NODENAME1, new byte[]{1,3})));
+        assertFalse(node3.equals(node1));
     }
 
     @Test
     public void testNodeIdentifier() {
 
         final NodeIdentifier node1 = new NodeIdentifier(NODENAME1);
-        assertEquals("getNodeType", NODENAME1, node1.getNodeType());
+        assertEquals(NODENAME1, node1.getNodeType());
         final NodeIdentifier node2 = new NodeIdentifier(NODENAME1);
         final AugmentationIdentifier node3 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2));
 
-        assertEquals("hashCode", node1.hashCode(), node2.hashCode());
-        assertEquals("compareTo", 0, node1.compareTo(node2));
-        assertTrue("compareTo", node1.compareTo(new NodeIdentifier(NODENAME3)) != 0);
+        assertEquals(node1.hashCode(), node2.hashCode());
+        assertEquals(0, node1.compareTo(node2));
+        assertTrue(node1.compareTo(new NodeIdentifier(NODENAME3)) != 0);
 
-        assertFalse("equals", node1.equals(null));
-        assertFalse("equals", node1.equals(node3));
-        assertTrue("equals", node1.equals(node1));
-        assertTrue("equals", node1.equals(node2));
-        assertFalse("equals", node1.equals(new NodeIdentifier(NODENAME3)));
-        assertFalse("equals", node1.equals(new Object()));
+        assertFalse(node1.equals(null));
+        assertFalse(node1.equals(node3));
+        assertTrue(node1.equals(node1));
+        assertTrue(node1.equals(node2));
+        assertFalse(node1.equals(new NodeIdentifier(NODENAME3)));
+        assertFalse(node1.equals(new Object()));
 
         // for code coverage
         assertNotNull(node1.toString());
@@ -333,26 +327,26 @@ public class YangInstanceIdentifierTest {
     public void testAugmentationIdentifier() {
 
         final AugmentationIdentifier node1 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2));
-        assertEquals("getPossibleChildNames", ImmutableSet.of(NODENAME1, NODENAME2), node1.getPossibleChildNames());
+        assertEquals(ImmutableSet.of(NODENAME1, NODENAME2), node1.getPossibleChildNames());
         final AugmentationIdentifier node2 = new AugmentationIdentifier(ImmutableSet.of(NODENAME2, NODENAME1));
         final AugmentationIdentifier node3 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME3));
         final AugmentationIdentifier node4 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2,
                     NODENAME3));
         final NodeIdentifier node5 = new NodeIdentifier(NODENAME3);
 
-        assertEquals("hashCode", node1.hashCode(), node2.hashCode());
+        assertEquals(node1.hashCode(), node2.hashCode());
 
-        assertTrue("equals", node1.equals(node1));
-        assertTrue("equals", node1.equals(node2));
-        assertFalse("equals", node1.equals(node3));
-        assertFalse("equals", node1.equals(new AugmentationIdentifier(ImmutableSet.of(NODENAME1))));
-        assertFalse("equals", node1.equals(new Object()));
+        assertTrue(node1.equals(node1));
+        assertTrue(node1.equals(node2));
+        assertFalse(node1.equals(node3));
+        assertFalse(node1.equals(new AugmentationIdentifier(ImmutableSet.of(NODENAME1))));
+        assertFalse(node1.equals(new Object()));
 
-        assertEquals("compareTo", -1, node1.compareTo(node5));
-        assertEquals("compareTo", 0, node1.compareTo(node2));
-        assertEquals("compareTo", 0, node1.compareTo(node2));
-        assertEquals("compareTo", 1, node1.compareTo(node4));
-        assertEquals("compareTo", -1, node4.compareTo(node1));
+        assertEquals(-1, node1.compareTo(node5));
+        assertEquals(0, node1.compareTo(node2));
+        assertEquals(0, node1.compareTo(node2));
+        assertEquals(1, node1.compareTo(node4));
+        assertEquals(-1, node4.compareTo(node1));
 
         // for code coverage
         assertNotNull(node1.toString());

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/DuplicityTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/DuplicityTest.java
index 640e7a7663bdf75feb560172ba7bcf130a3c52c1..c1a88124367d4a79b3dfb626febc8609f66811d0 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/DuplicityTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/DuplicityTest.java
@@ -7,22 +7,16 @@
  */
 package org.opendaylight.yangtools.yang.data.api.schema;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.mock;
 
 import java.util.Map;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class DuplicityTest {
     @Test
     public void testDuplicate() {
-        final LeafNode<?> leafNode = mock(LeafNode.class);
-        final ContainerNode containerNode = mock(ContainerNode.class);
-        final Map<NormalizedNode, DuplicateEntry> normalizedNodeDuplicateEntryMapNode = NormalizedNodes
-                .findDuplicates(leafNode);
-        final Map<NormalizedNode, DuplicateEntry> normalizedNodeDuplicateEntryMapContainer = NormalizedNodes
-                .findDuplicates(containerNode);
-        assertEquals(0, normalizedNodeDuplicateEntryMapNode.size());
-        assertEquals(0, normalizedNodeDuplicateEntryMapContainer.size());
+        assertEquals(Map.of(), NormalizedNodes.findDuplicates(mock(LeafNode.class)));
+        assertEquals(Map.of(), NormalizedNodes.findDuplicates(mock(ContainerNode.class)));
     }
 }

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java
index a9a0f81e4cc27bb1f51813362d0cddd248da6d5a..5cea4b8386d30b1bc0f70002fa6e9cf7ef9c67a5 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java
@@ -7,8 +7,8 @@
  */
 package org.opendaylight.yangtools.yang.data.api.schema;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.doReturn;
@@ -17,9 +17,9 @@ import static org.mockito.Mockito.mock;
 import com.google.common.collect.ImmutableSet;
 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.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
@@ -28,9 +28,8 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdent
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
+@ExtendWith(MockitoExtension.class)
 public class NormalizedNodesTest {
-
     @Test
     public void testGetDirectChild() {
         final PathArgument mockedPathArgument = mock(PathArgument.class);
@@ -134,7 +133,14 @@ public class NormalizedNodesTest {
 
         stringTree = NormalizedNodes.toStringTree(mockedAugmentationNode);
         assertNotNull(stringTree);
-        assertEquals("augmentation {\n    list-node {\n        list-node[key-leaf-value] {\n            leaf-node "
-                + "str-value-1\n        }\n    }\n}\n", stringTree);
+        assertEquals("""
+            augmentation {
+                list-node {
+                    list-node[key-leaf-value] {
+                        leaf-node str-value-1
+                    }
+                }
+            }
+            """, stringTree);
     }
 }

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriterTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriterTest.java
index 2d62b9b8d5fea94d83a79b034e42e02ac8d7a98b..e5c5b20070cef56a0367e58bc0fceb52c6c61b43 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriterTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriterTest.java
@@ -7,10 +7,10 @@
  */
 package org.opendaylight.yangtools.yang.data.api.schema.stream;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
+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.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.doReturn;
@@ -19,8 +19,8 @@ import static org.mockito.Mockito.mock;
 import java.io.IOException;
 import java.util.Set;
 import javax.xml.transform.dom.DOMSource;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.Revision;
@@ -44,14 +44,12 @@ import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
 
 public class NormalizedNodeWriterTest {
-
     private QNameModule bazModule;
-
     private QName myKeyedList;
     private QName myKeyLeaf;
     private QName myLeafList;
 
-    @Before
+    @BeforeEach
     public void setUp() {
         bazModule = QNameModule.create(XMLNamespace.of("baz-namespace"), Revision.of("1970-01-01"));
         myKeyedList = QName.create(bazModule, "my-keyed-list");