Hide JUnit5 tests

We have a number of warnings in the build, hide tests to make those
warnings go away.

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

diff --git a/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/LeafrefSerializeDeserializeTest.java b/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/LeafrefSerializeDeserializeTest.java
index 876fa7620d56aa29a66f36a1f1b2e8703922987c..41ed6e89585af13bb0f9e382c8f612d6d7954766 100644 (file)
--- a/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/LeafrefSerializeDeserializeTest.java
+++ b/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/LeafrefSerializeDeserializeTest.java
@@ -21,9 +21,9 @@ import org.opendaylight.yangtools.binding.DataObjectIdentifier;
 import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 
-public class LeafrefSerializeDeserializeTest extends AbstractBindingCodecTest {
+class LeafrefSerializeDeserializeTest extends AbstractBindingCodecTest {
     @Test
-    public void listReferenceTest() {
+    void listReferenceTest() {
         final var contYII = YangInstanceIdentifier.builder().node(Cont.QNAME).build();
         final var fromYangInstanceIdentifier = codecContext.fromYangInstanceIdentifier(contYII);
         assertNotNull(fromYangInstanceIdentifier);
@@ -41,7 +41,7 @@ public class LeafrefSerializeDeserializeTest extends AbstractBindingCodecTest {
     }
 
     @Test
-    public void uint32LeafrefTest() {
+    void uint32LeafrefTest() {
         final var contYII = YangInstanceIdentifier.builder().node(ContInt32.QNAME).build();
         final var fromYangInstanceIdentifier = codecContext.fromYangInstanceIdentifier(contYII);
         assertNotNull(fromYangInstanceIdentifier);
@@ -58,4 +58,3 @@ public class LeafrefSerializeDeserializeTest extends AbstractBindingCodecTest {
         assertEquals(refVal, value.getRefUnionInt32());
     }
 }
-

diff --git a/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/Mdsal673Test.java b/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/Mdsal673Test.java
index 90370b1f19c33ac816ccadd0c0f0b113d03db77a..4cbe5e1a8f4e6d3e9919e9ba147e08ef22f41d05 100644 (file)
--- a/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/Mdsal673Test.java
+++ b/binding/binding-data-codec-dynamic/src/test/java/org/opendaylight/yangtools/binding/data/codec/impl/Mdsal673Test.java
@@ -22,7 +22,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 
-public class Mdsal673Test extends AbstractBindingCodecTest {
+class Mdsal673Test extends AbstractBindingCodecTest {
     private static final NodeIdentifier FOO = new NodeIdentifier(Foo.QNAME);
     private static final NodeIdentifier BAR = new NodeIdentifier(Bar.QNAME);
 
@@ -66,7 +66,7 @@ public class Mdsal673Test extends AbstractBindingCodecTest {
      * Test when BAR is not empty container the {@code getBar} and {@code nonnullBar} returns the same BAR instance.
      */
     @Test
-    public void testNotEmptyContainer() {
+    void testNotEmptyContainer() {
         // FIXME: YANGTOOLS-1602: these should get translated to YangInstanceIdentifier.of(FOO)
         final var data = ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(FOO)

diff --git a/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsNullnessTest.java b/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsNullnessTest.java
index c32cb39e405b87739ae6706feff8dc92d9fd5a3d..d614ef4197d1875d2832438ca902888b54812f7e 100644 (file)
--- a/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsNullnessTest.java
+++ b/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsNullnessTest.java
@@ -11,118 +11,112 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.Uint16;
 import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.common.Uint64;
 import org.opendaylight.yangtools.yang.common.Uint8;
 
-public class ByteBufUtilsNullnessTest {
-    private ByteBuf buf;
-
-    @BeforeEach
-    public void before() {
-        buf = Unpooled.buffer();
-    }
+class ByteBufUtilsNullnessTest {
+    private final ByteBuf buf = Unpooled.buffer();
 
     @Test
-    public void testReadUint8() {
+    void testReadUint8() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.readUint8(null));
     }
 
     @Test
-    public void testReadUint16() {
+    void testReadUint16() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.readUint16(null));
     }
 
     @Test
-    public void testReadUint32() {
+    void testReadUint32() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.readUint8(null));
     }
 
     @Test
-    public void testReadUint64() {
+    void testReadUint64() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.readUint64(null));
     }
 
     @Test
-    public void testWriteNullBuf8() {
+    void testWriteNullBuf8() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(null, Uint8.ONE));
     }
 
     @Test
-    public void testWriteNullBuf16() {
+    void testWriteNullBuf16() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(null, Uint16.ONE));
     }
 
     @Test
-    public void testWriteNullBuf32() {
+    void testWriteNullBuf32() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(null, Uint32.ONE));
     }
 
     @Test
-    public void testWriteNullBuf64() {
+    void testWriteNullBuf64() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(null, Uint64.ONE));
     }
 
     @Test
-    public void testWriteNull8() {
+    void testWriteNull8() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(buf, (Uint8) null));
     }
 
     @Test
-    public void testWriteNull16() {
+    void testWriteNull16() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(buf, (Uint16) null));
     }
 
     @Test
-    public void testWriteNull32() {
+    void testWriteNull32() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(buf, (Uint32) null));
     }
 
     @Test
-    public void testWriteNull64() {
+    void testWriteNull64() {
         assertThrows(NullPointerException.class, () -> ByteBufUtils.write(null, (Uint64) null));
     }
 
     @Test
-    public void testWriteMandatoryByte() {
+    void testWriteMandatoryByte() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Byte) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryShort() {
+    void testWriteMandatoryShort() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Short) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryInt() {
+    void testWriteMandatoryInt() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Integer) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryLong() {
+    void testWriteMandatoryLong() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Long) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryUint8() {
+    void testWriteMandatoryUint8() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Uint8) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryUint16() {
+    void testWriteMandatoryUint16() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Uint16) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryUint32() {
+    void testWriteMandatoryUint32() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Uint32) null, "name"));
     }
 
     @Test
-    public void testWriteMandatoryUint64() {
+    void testWriteMandatoryUint64() {
         assertThrows(IllegalArgumentException.class, () -> ByteBufUtils.writeMandatory(buf, (Uint64) null, "name"));
     }
 }

diff --git a/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsTest.java b/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsTest.java
index bedcc865e00b46e582890e35b69848ca26c80aee..d9da7d2707437ef5db7e3787507cd180254cd845 100644 (file)
--- a/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsTest.java
+++ b/common/yang-common-netty/src/test/java/org/opendaylight/yangtools/yang/common/netty/ByteBufUtilsTest.java
@@ -17,33 +17,33 @@ import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.common.Uint64;
 import org.opendaylight.yangtools.yang.common.Uint8;
 
-public class ByteBufUtilsTest {
+class ByteBufUtilsTest {
     @Test
-    public void testWriteByte() {
+    void testWriteByte() {
         test(Byte.MAX_VALUE);
         test(Byte.MIN_VALUE);
     }
 
     @Test
-    public void testWriteShort() {
+    void testWriteShort() {
         test(Short.MAX_VALUE);
         test(Short.MIN_VALUE);
     }
 
     @Test
-    public void testWriteInt() {
+    void testWriteInt() {
         test(Integer.MAX_VALUE);
         test(Integer.MIN_VALUE);
     }
 
     @Test
-    public void testWriteLong() {
+    void testWriteLong() {
         test(Long.MAX_VALUE);
         test(Long.MIN_VALUE);
     }
 
     @Test
-    public void testWrite8() {
+    void testWrite8() {
         testUint(Uint8.ONE);
         testUint(Uint8.TWO);
         testUint(Uint8.TEN);
@@ -51,7 +51,7 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWrite16() {
+    void testWrite16() {
         testUint(Uint16.ONE);
         testUint(Uint16.TWO);
         testUint(Uint16.TEN);
@@ -59,7 +59,7 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWrite32() {
+    void testWrite32() {
         testUint(Uint32.ONE);
         testUint(Uint32.TWO);
         testUint(Uint32.TEN);
@@ -67,7 +67,7 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWrite64() {
+    void testWrite64() {
         testUint(Uint64.ONE);
         testUint(Uint64.TWO);
         testUint(Uint64.TEN);
@@ -75,8 +75,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptionalByte() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptionalByte() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Byte) null);
         assertEquals(0, buf.readableBytes());
 
@@ -85,8 +85,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptionalShort() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptionalShort() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Short) null);
         assertEquals(0, buf.readableBytes());
 
@@ -95,8 +95,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptionalInt() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptionalInt() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Integer) null);
         assertEquals(0, buf.readableBytes());
 
@@ -105,8 +105,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptionalLong() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptionalLong() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Long) null);
         assertEquals(0, buf.readableBytes());
 
@@ -115,8 +115,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptional8() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptional8() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Uint8) null);
         assertEquals(0, buf.readableBytes());
 
@@ -125,8 +125,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptional16() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptional16() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Uint16) null);
         assertEquals(0, buf.readableBytes());
 
@@ -135,8 +135,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptional32() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptional32() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Uint32) null);
         assertEquals(0, buf.readableBytes());
 
@@ -145,8 +145,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteOptional64() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteOptional64() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOptional(buf, (Uint64) null);
         assertEquals(0, buf.readableBytes());
 
@@ -155,7 +155,7 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZeroByte() {
+    void testWriteZeroByte() {
         final ByteBuf buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Byte) null);
         assertByte(buf, 0);
@@ -165,8 +165,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZeroShort() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZeroShort() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Short) null);
         assertShort(buf, 0);
 
@@ -175,8 +175,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZeroInt() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZeroInt() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Integer) null);
         assertInt(buf, 0);
 
@@ -185,8 +185,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZeroLong() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZeroLong() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Long) null);
         assertLong(buf, 0);
 
@@ -195,8 +195,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZero8() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZero8() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Uint8) null);
         assertUint(buf, Uint8.ZERO);
 
@@ -205,8 +205,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZero16() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZero16() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Uint16) null);
         assertUint(buf, Uint16.ZERO);
 
@@ -215,8 +215,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZero32() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZero32() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Uint32) null);
         assertUint(buf, Uint32.ZERO);
 
@@ -225,8 +225,8 @@ public class ByteBufUtilsTest {
     }
 
     @Test
-    public void testWriteZero64() {
-        final ByteBuf buf = Unpooled.buffer();
+    void testWriteZero64() {
+        final var buf = Unpooled.buffer();
         ByteBufUtils.writeOrZero(buf, (Uint64) null);
         assertUint(buf, Uint64.ZERO);
 

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 869b6260fe630ec760b241d9e632ad8c3a7d99c8..9250dcaab440d226ed1400ada2f36ba3dbfd4367 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
@@ -37,7 +37,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgum
  *
  * @author Thomas Pantelis
  */
-public class YangInstanceIdentifierTest {
+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");
@@ -47,7 +47,7 @@ public class YangInstanceIdentifierTest {
     private static final QName KEY3 = QName.create("test", "2014-05-28", "key3");
 
     @Test
-    public void testGetLastPathArgument() {
+    void testGetLastPathArgument() {
         YangInstanceIdentifier id1 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
                 new NodeIdentifier(NODENAME2));
         assertEquals(new NodeIdentifier(NODENAME2), id1.getLastPathArgument());
@@ -56,7 +56,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testHashCodeEquals() {
+    void testHashCodeEquals() {
         YangInstanceIdentifier id1 = YangInstanceIdentifier.of(NodeIdentifier.create(NODENAME1),
                 new NodeIdentifier(NODENAME2));
         YangInstanceIdentifier id2 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
@@ -65,7 +65,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testEquals() {
+    void testEquals() {
         final var id1 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
         final var id2 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
         final var id3 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME1));
@@ -80,13 +80,13 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testToString() {
+    void testToString() {
         final var id = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
         assertNotNull(id.toString());
     }
 
     @Test
-    public void testNode() {
+    void testNode() {
         final var id = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
 
         var newID = id.node(NODENAME3);
@@ -109,7 +109,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testRelativeTo() {
+    void testRelativeTo() {
         final YangInstanceIdentifier id1 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
                 new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
         final YangInstanceIdentifier id2 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
@@ -134,13 +134,13 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testContainsNull() {
+    void testContainsNull() {
         final var id = YangInstanceIdentifier.of(NODENAME1);
         assertThrows(NullPointerException.class, () -> id.contains(null));
     }
 
     @Test
-    public void testContains() {
+    void testContains() {
         final var id1 = YangInstanceIdentifier.of(NODENAME1, NODENAME2, NODENAME3, NODENAME4);
         final var id2 = YangInstanceIdentifier.of(NODENAME1, NODENAME2);
         final var id3 = YangInstanceIdentifier.of(NODENAME1, NODENAME2);
@@ -153,7 +153,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testOf() {
+    void testOf() {
         final var newID = YangInstanceIdentifier.of(NODENAME1);
         assertNotNull(newID);
         assertEquals(1, newID.getPathArguments().size());
@@ -164,7 +164,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testBuilder() {
+    void testBuilder() {
         var newID = YangInstanceIdentifier.builder()
                 .node(NODENAME1)
                 .nodeWithKey(NODENAME2, Map.of(KEY1, "foo"))
@@ -210,7 +210,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testNodeIdentifierWithPredicates() {
+    void testNodeIdentifierWithPredicates() {
 
         NodeIdentifierWithPredicates node1 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "foo");
         verifyNodeIdentifierWithPredicates("NodeIdentifierWithPredicates", node1, NODENAME1, KEY1, "foo");
@@ -251,7 +251,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testNodeWithValue() {
+    void testNodeWithValue() {
 
         NodeWithValue<?> node1 = new NodeWithValue<>(NODENAME1, "foo");
         assertEquals(NODENAME1, node1.getNodeType());
@@ -281,7 +281,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testNodeIdentifier() {
+    void testNodeIdentifier() {
 
         final NodeIdentifier node1 = new NodeIdentifier(NODENAME1);
         assertEquals(NODENAME1, node1.getNodeType());
@@ -318,7 +318,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testSerialization() throws IOException, ClassNotFoundException {
+    void testSerialization() throws IOException, ClassNotFoundException {
         final var fixed = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
         assertEquals(fixed, serdes(fixed));
 
@@ -330,7 +330,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testToOptimized() {
+    void testToOptimized() {
         final var fixed = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
         final var stacked = YangInstanceIdentifier.of().node(NodeIdentifier.create(NODENAME1))
                 .node(NodeIdentifier.create(NODENAME2));
@@ -343,7 +343,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testGetParent() {
+    void testGetParent() {
         final var fixed = YangInstanceIdentifier.of(NODENAME1);
         final var stacked = YangInstanceIdentifier.of().node(new NodeIdentifier(NODENAME1));
         final var twoStacked = stacked.node(NODENAME2);
@@ -355,7 +355,7 @@ public class YangInstanceIdentifierTest {
     }
 
     @Test
-    public void testIsEmpty() {
+    void testIsEmpty() {
         final YangInstanceIdentifier fixed = YangInstanceIdentifier.of(NODENAME1);
         final YangInstanceIdentifier stacked = YangInstanceIdentifier.of().node(NODENAME1);
 

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/codec/AbstractIllegalArgumentCodecTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/codec/AbstractIllegalArgumentCodecTest.java
index af7260a369dc639c566520d4fed1b72924ce79c5..75286bb600f9cb829e57b7b119e060635593572e 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/codec/AbstractIllegalArgumentCodecTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/codec/AbstractIllegalArgumentCodecTest.java
@@ -11,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
-public class AbstractIllegalArgumentCodecTest {
+class AbstractIllegalArgumentCodecTest {
     private static final class TestCodec extends AbstractIllegalArgumentCodec<String, String> {
         @Override
         protected String deserializeImpl(final String product) {
@@ -27,12 +27,12 @@ public class AbstractIllegalArgumentCodecTest {
     private final TestCodec codec = new TestCodec();
 
     @Test
-    public void testNullDeserialize() {
+    void testNullDeserialize() {
         assertThrows(NullPointerException.class, () -> codec.deserialize(null));
     }
 
     @Test
-    public void testNullSerialize() {
+    void testNullSerialize() {
         assertThrows(NullPointerException.class, () -> codec.serialize(null));
     }
 }

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 867ae5755a67e1bbf4b46f8f100d1e5caa1f0ab2..be00e036f592de08d500ab5b12cc650bdda55598 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
@@ -11,12 +11,12 @@ 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.doReturn;
-import static org.mockito.Mockito.mock;
 
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@@ -26,36 +26,44 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithV
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 
 @ExtendWith(MockitoExtension.class)
-public class NormalizedNodesTest {
+class NormalizedNodesTest {
+    @Mock
+    private ContainerNode mockedDataContainerNode;
+    @Mock
+    private ContainerNode mockedContainerNode;
+    @Mock
+    private LeafNode<?> mockedLeafNode;
+    @Mock
+    private LeafSetEntryNode<?> mockedLeafSetEntryNode;
+    @Mock
+    private SystemMapNode mockedMapNode;
+    @Mock
+    private MapEntryNode mockedMapEntryNode;
+    @Mock
+    private SystemLeafSetNode<?> mockedLeafSetNode;
+
     @Test
-    public void testGetDirectChild() {
+    void testGetDirectChild() {
         final var mockedPathArgument = new NodeIdentifier(QName.create("test", "test"));
 
-        final var mockedLeafNode = mock(LeafNode.class);
         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
 
-        final var mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
 
-        final var mockedDataContainerNode = mock(ContainerNode.class);
-        final var mockedContainerNode = mock(ContainerNode.class);
         doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any());
 
         assertEquals(Optional.of(mockedContainerNode),
             NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument));
 
-        final var mockedMapNode = mock(SystemMapNode.class);
         final QName listQName = QName.create("test-ns", "test-list");
         final QName listKeyQName = QName.create("test-ns", "test-list-key");
         final var nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
-        final var mockedMapEntryNode = mock(MapEntryNode.class);
         doReturn(mockedMapEntryNode).when(mockedMapNode).childByArg(any(NodeIdentifierWithPredicates.class));
 
         assertEquals(Optional.of(mockedMapEntryNode),
             NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates));
         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
 
-        final SystemLeafSetNode<?> mockedLeafSetNode = mock(SystemLeafSetNode.class);
         final QName leafListQName = QName.create("test-ns", "test-leaf-list");
         final NodeWithValue<?> nodeWithValue = new NodeWithValue<>(leafListQName, "str-value");
         doReturn(mockedLeafSetEntryNode).when(mockedLeafSetNode).childByArg(any(NodeWithValue.class));
@@ -64,10 +72,7 @@ public class NormalizedNodesTest {
     }
 
     @Test
-    public void testFindNode() {
-        final DataContainerNode mockedDataContainerNode = mock(ContainerNode.class);
-        final ContainerNode mockedContainerNode = mock(ContainerNode.class);
-        final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+    void testFindNode() {
         doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any());
         doReturn(mockedLeafNode).when(mockedContainerNode).childByArg(any());
 
@@ -95,8 +100,7 @@ public class NormalizedNodesTest {
     }
 
     @Test
-    public void testToStringTree() {
-        final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+    void testToStringTree() {
         final QName leafNodeQName = QName.create("test-ns", "2016-09-16", "leaf-node");
         final NodeIdentifier leafNodeId = new NodeIdentifier(leafNodeQName);
         doReturn(leafNodeId).when(mockedLeafNode).name();
@@ -108,11 +112,9 @@ public class NormalizedNodesTest {
 
         final QName listQName = QName.create("test-ns", "2016-09-16", "list-node");
 
-        final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
         final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
         doReturn(listNodeId).when(mockedMapNode).name();
 
-        final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
         final NodeIdentifierWithPredicates listEntryNodeId = NodeIdentifierWithPredicates.of(listQName,
                 leafNodeQName, "key-leaf-value");
         doReturn(listEntryNodeId).when(mockedMapEntryNode).name();

diff --git a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug2444Test.java b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug2444Test.java
index 4c46906434f5c2415b14522f98b56db76db74eef..75c8a814162c7ab33ed457324e95d928d9c94c3c 100644 (file)
--- a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug2444Test.java
+++ b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug2444Test.java
@@ -9,9 +9,9 @@ package org.opendaylight.yangtools.yang.model.export;
 
 import org.junit.jupiter.api.Test;
 
-public class Bug2444Test extends AbstractYinExportTest {
+class Bug2444Test extends AbstractYinExportTest {
     @Test
-    public void test() throws Exception {
+    void test() throws Exception {
         exportYinModules("/bugs/bug2444/yang", "/bugs/bug2444/yin");
     }
 }

diff --git a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug4504Test.java b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug4504Test.java
index aa2bf4f0723281b373eec6ae8d9577abbb1ef9d0..8a5097d6669e69167ddf2f4e6d3e1feb1276d66d 100644 (file)
--- a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug4504Test.java
+++ b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug4504Test.java
@@ -9,9 +9,9 @@ package org.opendaylight.yangtools.yang.model.export;
 
 import org.junit.jupiter.api.Test;
 
-public class Bug4504Test extends AbstractYinExportTest {
+class Bug4504Test extends AbstractYinExportTest {
     @Test
-    public void test() throws Exception {
+    void test() throws Exception {
         exportYinModules("/bugs/bug4504", null);
     }
 }

diff --git a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug6856Test.java b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug6856Test.java
index 1095be684773d355ee8f8e7c1d283c2298995704..dd6139fc76ce9555a158c04900141eeefd66198d 100644 (file)
--- a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug6856Test.java
+++ b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/Bug6856Test.java
@@ -17,9 +17,9 @@ import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.Revision;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
-public class Bug6856Test {
+class Bug6856Test {
     @Test
-    public void testImplicitInputAndOutputInRpc() throws Exception {
+    void testImplicitInputAndOutputInRpc() throws Exception {
         final var schemaContext = YangParserTestUtils.parseYang("""
             module foo {
               namespace foo;
@@ -45,7 +45,7 @@ public class Bug6856Test {
     }
 
     @Test
-    public void testExplicitInputAndOutputInRpc() throws Exception {
+    void testExplicitInputAndOutputInRpc() throws Exception {
         final var schemaContext = YangParserTestUtils.parseYang("""
             module bar {
               namespace bar;

diff --git a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitterTest.java b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitterTest.java
index aed80ad130fa12ab859fc67b72a1a6aa45d81d8b..ceec051a1f8cc4c2961173f7c9fd780d58a5c9c6 100644 (file)
--- a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitterTest.java
+++ b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitterTest.java
@@ -9,9 +9,9 @@ package org.opendaylight.yangtools.yang.model.export;
 
 import org.junit.jupiter.api.Test;
 
-public class SchemaContextEmitterTest extends AbstractYinExportTest {
+class SchemaContextEmitterTest extends AbstractYinExportTest {
     @Test
-    public void testSchemaContextEmitter() throws Exception {
+    void testSchemaContextEmitter() throws Exception {
         exportYinModules("/schema-context-emitter-test", "/schema-context-emitter-test");
     }
 }

diff --git a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YT1313Test.java b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YT1313Test.java
index 0dd1a1a8ac5552b6016ddd02f690f1be4b9945b8..ecef41f177bfa857ac125efcbcc931273390173a 100644 (file)
--- a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YT1313Test.java
+++ b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YT1313Test.java
@@ -13,9 +13,9 @@ import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
-public class YT1313Test {
+class YT1313Test {
     @Test
-    public void testSubmoduleImportPrefixes() {
+    void testSubmoduleImportPrefixes() {
         final var bar = YangParserTestUtils.parseYang("""
             module bar {
               namespace bar;
@@ -60,7 +60,6 @@ public class YT1313Test {
             }""")
             .getModuleStatement(QNameModule.of("bar"));
 
-        final StatementPrefixResolver resolver = StatementPrefixResolver.forModule(bar);
-        assertNotNull(resolver);
+        assertNotNull(StatementPrefixResolver.forModule(bar));
     }
 }

diff --git a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YangTextSnippetTest.java b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YangTextSnippetTest.java
index b13d8a16517e39ecc2baebf30ef3757744470c03..73451a7c8eac8ef99ce55a626689d48c44ca8a09 100644 (file)
--- a/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YangTextSnippetTest.java
+++ b/model/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/YangTextSnippetTest.java
@@ -16,14 +16,14 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
-public class YangTextSnippetTest {
+class YangTextSnippetTest {
     @Test
-    public void testNotification() {
+    void testNotification() {
         assertFormat(YangParserTestUtils.parseYangResource("/bugs/bug2444/yang/notification.yang"));
     }
 
     @Test
-    public void testSubmoduleNamespaces() {
+    void testSubmoduleNamespaces() {
         assertFormat(YangParserTestUtils.parseYang("""
             module module1 {
               yang-version "1.1";

diff --git a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/BitsTypeTest.java b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/BitsTypeTest.java
index b87ae5d1afcdabc0cc9109a7a49a8c19488d2785..22ca33fe7d3f973c5821276675c7064472b668c1 100644 (file)
--- a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/BitsTypeTest.java
+++ b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/BitsTypeTest.java
@@ -24,9 +24,9 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
 
 @ExtendWith(MockitoExtension.class)
-public class BitsTypeTest {
+class BitsTypeTest {
     @Mock
-    Bit bit;
+    private Bit bit;
 
     @Test
     void canCreateBitsType() {

diff --git a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EmptyTypeTest.java b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EmptyTypeTest.java
index 86a602428b7e4d768c8536c4e958c0f8e0c1e6dd..aba97c394e68a98285cc4992e6d813da6dbba785 100644 (file)
--- a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EmptyTypeTest.java
+++ b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EmptyTypeTest.java
@@ -15,13 +15,12 @@ import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.TypeDefinitions;
 
 class EmptyTypeTest {
     @Test
     void canCreateEmptyType() {
-        EmptyTypeDefinition emptyType = BaseTypes.emptyType();
+        final var emptyType = BaseTypes.emptyType();
 
         assertEquals(TypeDefinitions.EMPTY, emptyType.getQName(), "QName");
         assertNull(emptyType.getBaseType(), "BaseType");

diff --git a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EnumPairImplTest.java b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EnumPairImplTest.java
index 18c03da4de1c0fe1a53eecd8c3832ace90632ac1..f5287557ba85c5565a964194a323106c07da880f 100644 (file)
--- a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EnumPairImplTest.java
+++ b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/EnumPairImplTest.java
@@ -10,20 +10,25 @@ package org.opendaylight.yangtools.yang.model.ri.type;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mockito.Mockito.mock;
 
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 
+@ExtendWith(MockitoExtension.class)
 class EnumPairImplTest {
+    @Mock
+    private UnknownSchemaNode mockedUnknownSchemaNodeA;
+    @Mock
+    private UnknownSchemaNode mockedUnknownSchemaNodeB;
+
     @Test
     void testEnumPairImpl() {
-        final var mockedUnknownSchemaNodeA = mock(UnknownSchemaNode.class);
-        final var mockedUnknownSchemaNodeB = mock(UnknownSchemaNode.class);
-
         final var unknownSchemaNodes = List.of(mockedUnknownSchemaNodeA, mockedUnknownSchemaNodeB);
 
         final var enumPair = EnumPairBuilder.create("enum-zero", 0).setStatus(Status.DEPRECATED)

diff --git a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/Int8Test.java b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/Int8Test.java
index 6bb10aef1e2a2e06aafb242b0d34d3e6e3af656f..6df1c022b285d44926203452a03562d031f7e494 100644 (file)
--- a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/Int8Test.java
+++ b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/Int8Test.java
@@ -21,8 +21,7 @@ class Int8Test {
         var int8Second = BaseTypes.int8Type();
         assertSame(int8, int8Second, "The method 'getInstance()' has to return the same instance");
         assertNull(int8.getBaseType(), "The method 'getBaseType()' is returning incorrect value");
-        assertEquals(Optional.empty(),
-            int8.getDefaultValue(),
+        assertEquals(Optional.empty(), int8.getDefaultValue(),
             "The method 'getDefaultType()' is returning incorrect value");
     }
 }

diff --git a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/LeafrefTest.java b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/LeafrefTest.java
index 69b330fb93ae1ab52c2fa8f0f79677687a1b043c..cbd4d9a4082f3eb19df35416ac922c110a71d1b6 100644 (file)
--- a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/LeafrefTest.java
+++ b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/LeafrefTest.java
@@ -13,24 +13,30 @@ import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.mock;
 
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.PathExpression;
 import org.opendaylight.yangtools.yang.model.api.Status;
 
+@ExtendWith(MockitoExtension.class)
 class LeafrefTest {
+    @Mock
+    private PathExpression expression;
+    @Mock
+    private PathExpression expression2;
+
     @Test
     void testMethodsOfLeafrefTest() {
         final var qname = QName.create("test", "List1");
-        final var revision = mock(PathExpression.class);
-        final var revision2 = mock(PathExpression.class);
 
-        final var leafref = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(revision).build();
-        final var leafref2 = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(revision2).build();
-        final var leafref3 = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(revision).build();
+        final var leafref = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(expression).build();
+        final var leafref2 = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(expression2).build();
+        final var leafref3 = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(expression).build();
         final var leafref4 = leafref;
 
         assertNotNull(leafref, "Object 'leafref' shouldn't be null.");
@@ -43,12 +49,10 @@ class LeafrefTest {
         assertEquals(Status.CURRENT, leafref.getStatus(), "Status of 'leafref' is current.");
         assertTrue(leafref.getUnknownSchemaNodes().isEmpty(),
                 "Object 'leafref' shouldn't have any unknown schema nodes.");
-        assertEquals(revision,
-                leafref.getPathStatement(),
+        assertEquals(expression, leafref.getPathStatement(),
                 "Revision aware XPath of 'leafref' should be '/test:Cont1/test:List1'.");
         assertNotNull(leafref.toString(), "String representation of 'leafref' shouldn't be null.");
-        assertNotEquals(leafref.hashCode(),
-                leafref2.hashCode(),
+        assertNotEquals(leafref.hashCode(), leafref2.hashCode(),
                 "Hash codes of two different object of type Leafref shouldn't be equal.");
         assertEquals(leafref, leafref3, "Objects of type Leafref should be equal.");
         assertEquals(leafref, leafref4, "Objects of type Leafref should be equal.");
@@ -60,8 +64,7 @@ class LeafrefTest {
     @Test
     void testRequireInstanceSubstatement() {
         final var qname = QName.create("test", "my-leafref");
-        final var path = mock(PathExpression.class);
-        final var leafrefTypeBuilder = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(path);
+        final var leafrefTypeBuilder = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(expression);
 
         assertTrue(leafrefTypeBuilder.build().requireInstance());
 

diff --git a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/TypeTest.java b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/TypeTest.java
index 06d16e581545fc4aba7eddd4d629830178d03af4..f141f5c5a39e0411e73947963bd6fbae82505297 100644 (file)
--- a/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/TypeTest.java
+++ b/model/yang-model-ri/src/test/java/org/opendaylight/yangtools/yang/model/ri/type/TypeTest.java
@@ -18,11 +18,13 @@ import static org.mockito.Mockito.mock;
 
 import com.google.common.collect.ImmutableRangeSet;
 import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
 import java.util.List;
 import java.util.Optional;
 import org.eclipse.jdt.annotation.NonNull;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
@@ -33,23 +35,10 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
 import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
-import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
-import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
 
+@ExtendWith(MockitoExtension.class)
 class TypeTest {
     private static final @NonNull QName Q_NAME = QName.create("test.namespace", "2016-01-01", "test-name");
     private static final Bit BIT_A = BitBuilder.create(Q_NAME.getLocalName(), Uint32.valueOf(55L))
@@ -57,6 +46,11 @@ class TypeTest {
         .setReference("reference")
         .build();
 
+    @Mock
+    private IdentitySchemaNode identitySchemaNode;
+    @Mock
+    private PatternConstraint patternConstraint;
+
     @Test
     void binaryTypeTest() {
         final var baseBinaryType1 = BaseBinaryType.INSTANCE;
@@ -64,58 +58,56 @@ class TypeTest {
         hashCodeEqualsToStringTest(baseBinaryType1, baseBinaryType2);
         assertEquals(baseBinaryType1.getLengthConstraint(), baseBinaryType2.getLengthConstraint());
 
-        final DerivedBinaryType derivedBinaryType1 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType1,
-            Q_NAME).build();
-        final DerivedBinaryType derivedBinaryType2 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType2,
-            Q_NAME).build();
+        final var derivedBinaryType1 = assertInstanceOf(DerivedBinaryType.class,
+            DerivedTypes.derivedTypeBuilder(baseBinaryType1, Q_NAME).build());
+        final var derivedBinaryType2 = assertInstanceOf(DerivedBinaryType.class,
+            DerivedTypes.derivedTypeBuilder(baseBinaryType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedBinaryType1, derivedBinaryType2);
 
-        final RestrictedBinaryType restrictedBinaryType1 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
-                baseBinaryType1, Q_NAME).buildType();
-        final RestrictedBinaryType restrictedBinaryType2 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
-                baseBinaryType2, Q_NAME).buildType();
+        final var restrictedBinaryType1 = assertInstanceOf(RestrictedBinaryType.class,
+            RestrictedTypes.newBinaryBuilder(baseBinaryType1, Q_NAME).buildType());
+        final RestrictedBinaryType restrictedBinaryType2 = assertInstanceOf(RestrictedBinaryType.class,
+            RestrictedTypes.newBinaryBuilder(baseBinaryType2, Q_NAME).buildType());
         hashCodeEqualsToStringTest(restrictedBinaryType1, restrictedBinaryType2);
 
-        final LengthRestrictedTypeBuilder<BinaryTypeDefinition> lengthRestrictedTypeBuilder = RestrictedTypes
-                .newBinaryBuilder(baseBinaryType1, Q_NAME);
-        final BaseBinaryType baseBinaryType = (BaseBinaryType)lengthRestrictedTypeBuilder.build();
+        final var lengthRestrictedTypeBuilder = RestrictedTypes.newBinaryBuilder(baseBinaryType1, Q_NAME);
+        final var baseBinaryType = assertInstanceOf(BaseBinaryType.class, lengthRestrictedTypeBuilder.build());
         assertEquals(baseBinaryType, baseBinaryType1);
         concreteBuilderTest(baseBinaryType1, derivedBinaryType1);
     }
 
     @Test
     void booleanTypeTest() {
-        final BaseBooleanType baseBooleanType1 = BaseBooleanType.INSTANCE;
-        final BaseBooleanType baseBooleanType2 = (BaseBooleanType)BaseTypes.booleanType();
+        final var baseBooleanType1 = BaseBooleanType.INSTANCE;
+        final var baseBooleanType2 = assertInstanceOf(BaseBooleanType.class, BaseTypes.booleanType());
         hashCodeEqualsToStringTest(baseBooleanType1, baseBooleanType2);
 
-        final DerivedBooleanType derivedBooleanType1 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
-                baseBooleanType1, Q_NAME).build();
-        final DerivedBooleanType derivedBooleanType2 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
-                baseBooleanType1, Q_NAME).build();
+        final var derivedBooleanType1 = assertInstanceOf(DerivedBooleanType.class,
+            DerivedTypes.derivedTypeBuilder(baseBooleanType1, Q_NAME).build());
+        final var derivedBooleanType2 = assertInstanceOf(DerivedBooleanType.class,
+            DerivedTypes.derivedTypeBuilder(baseBooleanType1, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedBooleanType1, derivedBooleanType2);
 
-        restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, Q_NAME), RestrictedTypes
-                .newBooleanBuilder(baseBooleanType2, Q_NAME));
+        restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, Q_NAME),
+            RestrictedTypes.newBooleanBuilder(baseBooleanType2, Q_NAME));
         concreteBuilderTest(baseBooleanType1, derivedBooleanType1);
     }
 
     @Test
     void identityrefTypeTest() {
-        final IdentityrefTypeBuilder identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(Q_NAME);
-        final IdentitySchemaNode identitySchemaNode = mock(IdentitySchemaNode.class);
+        final var identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(Q_NAME);
         doReturn("identitySchemaNode").when(identitySchemaNode).toString();
         identityrefTypeBuilder1.addIdentity(identitySchemaNode);
-        final IdentityrefTypeDefinition identityrefTypeDefinition1 = identityrefTypeBuilder1.build();
-        final IdentityrefTypeBuilder identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(Q_NAME);
+        final var identityrefTypeDefinition1 = identityrefTypeBuilder1.build();
+        final var identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(Q_NAME);
         identityrefTypeBuilder2.addIdentity(identitySchemaNode);
-        final IdentityrefTypeDefinition identityrefTypeDefinition2 = identityrefTypeBuilder2.build();
+        final var identityrefTypeDefinition2 = identityrefTypeBuilder2.build();
         hashCodeEqualsToStringTest(identityrefTypeDefinition1, identityrefTypeDefinition2);
 
-        final DerivedIdentityrefType derivedIdentityrefType1 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
-                identityrefTypeDefinition1, Q_NAME).build();
-        final DerivedIdentityrefType derivedIdentityrefType2 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
-                identityrefTypeDefinition2, Q_NAME).build();
+        final var derivedIdentityrefType1 = assertInstanceOf(DerivedIdentityrefType.class,
+            DerivedTypes.derivedTypeBuilder(identityrefTypeDefinition1, Q_NAME).build());
+        final var derivedIdentityrefType2 = assertInstanceOf(DerivedIdentityrefType.class,
+            DerivedTypes.derivedTypeBuilder(identityrefTypeDefinition2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedIdentityrefType1, derivedIdentityrefType2);
         concreteBuilderTest(identityrefTypeDefinition1, derivedIdentityrefType1);
 
@@ -125,122 +117,117 @@ class TypeTest {
 
     @Test
     void decimalTypeTest() {
-        final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
-                .setFractionDigits(1)
-                .buildType();
-        final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
-                .setFractionDigits(1)
-                .buildType();
+        final var baseDecimalType1 = assertInstanceOf(BaseDecimalType.class,
+            BaseTypes.decimalTypeBuilder(Q_NAME).setFractionDigits(1).buildType());
+        final var baseDecimalType2 = assertInstanceOf(BaseDecimalType.class,
+            BaseTypes.decimalTypeBuilder(Q_NAME).setFractionDigits(1).buildType());
         hashCodeEqualsToStringTest(baseDecimalType1, baseDecimalType2);
         assertEquals(baseDecimalType1.getFractionDigits(), baseDecimalType2.getFractionDigits());
 
-        final DerivedDecimalType derivedDecimalType1 = (DerivedDecimalType)DerivedTypes
-                .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
-        final DerivedDecimalType derivedDecimalType2 = (DerivedDecimalType)DerivedTypes
-                .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
+        final var derivedDecimalType1 = assertInstanceOf(DerivedDecimalType.class,
+            DerivedTypes.derivedTypeBuilder(baseDecimalType1, Q_NAME).build());
+        final var derivedDecimalType2 = assertInstanceOf(DerivedDecimalType.class,
+            DerivedTypes.derivedTypeBuilder(baseDecimalType1, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedDecimalType1, derivedDecimalType2);
 
-        final RestrictedDecimalType restrictedDecimalType1 = (RestrictedDecimalType)
-                RestrictedTypes.newDecima64Builder(baseDecimalType1, Q_NAME).buildType();
-        final RestrictedDecimalType restrictedDecimalType2 = (RestrictedDecimalType)
-                RestrictedTypes.newDecima64Builder(baseDecimalType2, Q_NAME).buildType();
+        final var restrictedDecimalType1 = assertInstanceOf(RestrictedDecimalType.class,
+            RestrictedTypes.newDecima64Builder(baseDecimalType1, Q_NAME).buildType());
+        final var restrictedDecimalType2 = assertInstanceOf(RestrictedDecimalType.class,
+            RestrictedTypes.newDecima64Builder(baseDecimalType2, Q_NAME).buildType());
         hashCodeEqualsToStringTest(restrictedDecimalType1, restrictedDecimalType2);
         concreteBuilderTest(baseDecimalType1, derivedDecimalType1);
     }
 
     @Test
     void emptyTypeTest() {
-        final BaseEmptyType baseEmptyType1 = BaseEmptyType.INSTANCE;
-        final BaseEmptyType baseEmptyType2 = (BaseEmptyType)BaseTypes.emptyType();
+        final var baseEmptyType1 = BaseEmptyType.INSTANCE;
+        final var baseEmptyType2 = assertInstanceOf(BaseEmptyType.class, BaseTypes.emptyType());
         hashCodeEqualsToStringTest(baseEmptyType1, baseEmptyType2);
 
-        final DerivedEmptyType derivedEmptyType1 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
-                baseEmptyType1, Q_NAME).build();
-        final DerivedEmptyType derivedEmptyType2 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
-                baseEmptyType2, Q_NAME).build();
+        final DerivedEmptyType derivedEmptyType1 = assertInstanceOf(DerivedEmptyType.class,
+            DerivedTypes.derivedTypeBuilder(baseEmptyType1, Q_NAME).build());
+        final DerivedEmptyType derivedEmptyType2 = assertInstanceOf(DerivedEmptyType.class,
+            DerivedTypes.derivedTypeBuilder(baseEmptyType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedEmptyType1, derivedEmptyType2);
 
         restrictedBuilderTest(RestrictedTypes.newEmptyBuilder(baseEmptyType1, Q_NAME),
-                RestrictedTypes.newEmptyBuilder(baseEmptyType2, Q_NAME));
+            RestrictedTypes.newEmptyBuilder(baseEmptyType2, Q_NAME));
         concreteBuilderTest(baseEmptyType1, derivedEmptyType1);
     }
 
     @Test
     void instanceIdentifierTypeTest() {
-        final BaseInstanceIdentifierType baseInstanceIdentifierType1 = BaseInstanceIdentifierType.INSTANCE;
-        final BaseInstanceIdentifierType baseInstanceIdentifierType2 = (BaseInstanceIdentifierType)BaseTypes
-                .instanceIdentifierType();
+        final var baseInstanceIdentifierType1 = BaseInstanceIdentifierType.INSTANCE;
+        final var baseInstanceIdentifierType2 = assertInstanceOf(BaseInstanceIdentifierType.class,
+            BaseTypes.instanceIdentifierType());
         hashCodeEqualsToStringTest(baseInstanceIdentifierType1, baseInstanceIdentifierType2);
         assertFalse(baseInstanceIdentifierType1.requireInstance());
 
-        final DerivedInstanceIdentifierType derivedInstanceIdentifierType1 = (DerivedInstanceIdentifierType)
-                DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType1, Q_NAME).build();
-        final DerivedInstanceIdentifierType derivedInstanceIdentifierType2 = (DerivedInstanceIdentifierType)
-                DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType2, Q_NAME).build();
+        final var derivedInstanceIdentifierType1 = assertInstanceOf(DerivedInstanceIdentifierType.class,
+            DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType1, Q_NAME).build());
+        final var derivedInstanceIdentifierType2 = assertInstanceOf(DerivedInstanceIdentifierType.class,
+            DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedInstanceIdentifierType1, derivedInstanceIdentifierType2);
 
-        final InstanceIdentifierTypeBuilder instanceIdentifierBuilder1 = RestrictedTypes
-                .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
+        final var instanceIdentifierBuilder1 =
+            RestrictedTypes.newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
         instanceIdentifierBuilder1.setRequireInstance(true);
-        final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition1 = instanceIdentifierBuilder1
-                .buildType();
-        final InstanceIdentifierTypeBuilder instanceIdentifierBuilder2 = RestrictedTypes
-                .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
+        final var instanceIdentifierTypeDefinition1 = instanceIdentifierBuilder1.buildType();
+        final var instanceIdentifierBuilder2 =
+            RestrictedTypes.newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
         instanceIdentifierBuilder2.setRequireInstance(true);
-        final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition2 = instanceIdentifierBuilder2
-                .buildType();
+        final var instanceIdentifierTypeDefinition2 = instanceIdentifierBuilder2.buildType();
         hashCodeEqualsToStringTest(instanceIdentifierTypeDefinition2, instanceIdentifierTypeDefinition1);
         concreteBuilderTest(baseInstanceIdentifierType1, derivedInstanceIdentifierType1);
     }
 
     @Test
     void integerTypeTest() {
-        final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
-        final Int16TypeDefinition integerTypeDefinition16 = BaseTypes.int16Type();
-        final Int32TypeDefinition integerTypeDefinition32 = BaseTypes.int32Type();
-        final Int64TypeDefinition integerTypeDefinition64 = BaseTypes.int64Type();
+        final var integerTypeDefinition8 = BaseTypes.int8Type();
+        final var integerTypeDefinition16 = BaseTypes.int16Type();
+        final var integerTypeDefinition32 = BaseTypes.int32Type();
+        final var integerTypeDefinition64 = BaseTypes.int64Type();
         testInstance(BaseInt8Type.INSTANCE, integerTypeDefinition8);
         testInstance(BaseInt16Type.INSTANCE, integerTypeDefinition16);
         testInstance(BaseInt32Type.INSTANCE, integerTypeDefinition32);
         testInstance(BaseInt64Type.INSTANCE, integerTypeDefinition64);
 
-        final RestrictedInt8Type restrictedIntegerType1 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
-                integerTypeDefinition8, Q_NAME).buildType();
-        final RestrictedInt8Type restrictedIntegerType2 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
-                BaseInt8Type.INSTANCE, Q_NAME).buildType();
+        final var restrictedIntegerType1 = assertInstanceOf(RestrictedInt8Type.class,
+            RestrictedTypes.newInt8Builder(integerTypeDefinition8, Q_NAME).buildType());
+        final var restrictedIntegerType2 = assertInstanceOf(RestrictedInt8Type.class,
+            RestrictedTypes.newInt8Builder(BaseInt8Type.INSTANCE, Q_NAME).buildType());
         hashCodeEqualsToStringTest(restrictedIntegerType1, restrictedIntegerType2);
 
-        final Uint8TypeDefinition integerTypeDefinitionu8 = BaseTypes.uint8Type();
-        final Uint16TypeDefinition integerTypeDefinitionu16 = BaseTypes.uint16Type();
-        final Uint32TypeDefinition integerTypeDefinitionu32 = BaseTypes.uint32Type();
-        final Uint64TypeDefinition integerTypeDefinitionu64 = BaseTypes.uint64Type();
+        final var integerTypeDefinitionu8 = BaseTypes.uint8Type();
+        final var integerTypeDefinitionu16 = BaseTypes.uint16Type();
+        final var integerTypeDefinitionu32 = BaseTypes.uint32Type();
+        final var integerTypeDefinitionu64 = BaseTypes.uint64Type();
         testInstance(BaseUint8Type.INSTANCE, integerTypeDefinitionu8);
         testInstance(BaseUint16Type.INSTANCE, integerTypeDefinitionu16);
         testInstance(BaseUint32Type.INSTANCE, integerTypeDefinitionu32);
         testInstance(BaseUint64Type.INSTANCE, BaseTypes.baseTypeOf(integerTypeDefinitionu64));
 
-        final DerivedInt8Type derivedIntegerType1 = (DerivedInt8Type)DerivedTypes
-                .derivedTypeBuilder(integerTypeDefinition8, Q_NAME).build();
-        final DerivedInt8Type derivedIntegerType2 = (DerivedInt8Type)DerivedTypes
-                .derivedTypeBuilder(BaseInt8Type.INSTANCE, Q_NAME).build();
+        final var derivedIntegerType1 = assertInstanceOf(DerivedInt8Type.class,
+            DerivedTypes.derivedTypeBuilder(integerTypeDefinition8, Q_NAME).build());
+        final var derivedIntegerType2 = assertInstanceOf(DerivedInt8Type.class,
+            DerivedTypes.derivedTypeBuilder(BaseInt8Type.INSTANCE, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedIntegerType1, derivedIntegerType2);
 
-        final DerivedUint8Type derivedUnsignedType1 = (DerivedUint8Type)DerivedTypes
-                .derivedTypeBuilder(integerTypeDefinitionu8, Q_NAME).build();
-        final DerivedUint8Type derivedUnsignedType2 = (DerivedUint8Type)DerivedTypes
-                .derivedTypeBuilder(BaseUint8Type.INSTANCE, Q_NAME).build();
+        final var derivedUnsignedType1 = assertInstanceOf(DerivedUint8Type.class,
+            DerivedTypes.derivedTypeBuilder(integerTypeDefinitionu8, Q_NAME).build());
+        final var derivedUnsignedType2 = assertInstanceOf(DerivedUint8Type.class,
+            DerivedTypes.derivedTypeBuilder(BaseUint8Type.INSTANCE, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedUnsignedType1, derivedUnsignedType2);
 
-        final RestrictedUint8Type restrictedUnsignedType1 = (RestrictedUint8Type)RestrictedTypes
-                .newUint8Builder(integerTypeDefinitionu8, Q_NAME).buildType();
-        final RestrictedUint8Type restrictedUnsignedType2 = (RestrictedUint8Type)RestrictedTypes
-                .newUint8Builder(BaseUint8Type.INSTANCE, Q_NAME).buildType();
+        final var restrictedUnsignedType1 = assertInstanceOf(RestrictedUint8Type.class,
+            RestrictedTypes.newUint8Builder(integerTypeDefinitionu8, Q_NAME).buildType());
+        final var restrictedUnsignedType2 = assertInstanceOf(RestrictedUint8Type.class,
+            RestrictedTypes.newUint8Builder(BaseUint8Type.INSTANCE, Q_NAME).buildType());
         hashCodeEqualsToStringTest(restrictedUnsignedType1, restrictedUnsignedType2);
         concreteBuilderTest(integerTypeDefinition8, derivedIntegerType1);
         concreteBuilderTest(integerTypeDefinitionu8, derivedUnsignedType2);
 
-        final DerivedTypeBuilder<?> derivedTypeBuilder = DerivedTypes.derivedTypeBuilder(integerTypeDefinition8,
-            Q_NAME);
+        final var derivedTypeBuilder = DerivedTypes.derivedTypeBuilder(integerTypeDefinition8, Q_NAME);
         derivedTypeBuilder.setDefaultValue(1);
         derivedTypeBuilder.setDescription("test-description");
         derivedTypeBuilder.setReference("test-reference");
@@ -254,43 +241,42 @@ class TypeTest {
 
     @Test
     void stringTypeTest() {
-        final BaseStringType baseStringType1 = BaseStringType.INSTANCE;
-        final BaseStringType baseStringType2 = (BaseStringType)BaseTypes.stringType();
+        final var baseStringType1 = BaseStringType.INSTANCE;
+        final var baseStringType2 = assertInstanceOf(BaseStringType.class, BaseTypes.stringType());
         hashCodeEqualsToStringTest(baseStringType1, baseStringType2);
         assertEquals(baseStringType1.getLengthConstraint(), baseStringType2.getLengthConstraint());
         assertEquals(baseStringType1.getPatternConstraints(), baseStringType2.getPatternConstraints());
 
-        final DerivedStringType derivedStringType1 = (DerivedStringType)
-                DerivedTypes.derivedTypeBuilder(baseStringType1, Q_NAME).build();
-        final DerivedStringType derivedStringType2 = (DerivedStringType)
-                DerivedTypes.derivedTypeBuilder(baseStringType2, Q_NAME).build();
+        final var derivedStringType1 = assertInstanceOf(DerivedStringType.class,
+            DerivedTypes.derivedTypeBuilder(baseStringType1, Q_NAME).build());
+        final var derivedStringType2 = assertInstanceOf(DerivedStringType.class,
+            DerivedTypes.derivedTypeBuilder(baseStringType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedStringType1, derivedStringType2);
 
-        final RestrictedStringType restrictedStringType1 = (RestrictedStringType)RestrictedTypes
-                .newStringBuilder(baseStringType1, Q_NAME).buildType();
-        final RestrictedStringType restrictedStringType2 = (RestrictedStringType)RestrictedTypes
-                .newStringBuilder(baseStringType2, Q_NAME).buildType();
+        final var restrictedStringType1 = assertInstanceOf(RestrictedStringType.class,
+            RestrictedTypes.newStringBuilder(baseStringType1, Q_NAME).buildType());
+        final var restrictedStringType2 = assertInstanceOf(RestrictedStringType.class,
+            RestrictedTypes.newStringBuilder(baseStringType2, Q_NAME).buildType());
         hashCodeEqualsToStringTest(restrictedStringType1, restrictedStringType2);
         concreteBuilderTest(baseStringType1, derivedStringType1);
 
-        final StringTypeBuilder stringTypeBuilder = new StringTypeBuilder(baseStringType1, Q_NAME);
-        stringTypeBuilder.addPatternConstraint(mock(PatternConstraint.class));
-        final StringTypeDefinition stringTypeDefinition = stringTypeBuilder.buildType();
-        assertNotNull(stringTypeDefinition);
+        final var stringTypeBuilder = new StringTypeBuilder(baseStringType1, Q_NAME);
+        stringTypeBuilder.addPatternConstraint(patternConstraint);
+        assertNotNull(stringTypeBuilder.buildType());
     }
 
     @Test
     void bitsTypeTest() {
-        final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME).addBit(BIT_A);
-        final BitsTypeDefinition bitsTypeDefinition1 = bitsTypeBuilder.build();
-        final BitsTypeDefinition bitsTypeDefinition2 = bitsTypeBuilder.build();
+        final var bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME).addBit(BIT_A);
+        final var bitsTypeDefinition1 = bitsTypeBuilder.build();
+        final var bitsTypeDefinition2 = bitsTypeBuilder.build();
         hashCodeEqualsToStringTest(bitsTypeDefinition1, bitsTypeDefinition2);
         assertEquals(bitsTypeDefinition1.getBits(), bitsTypeDefinition1.getBits());
 
-        final DerivedBitsType derivedBitsType1 = (DerivedBitsType)DerivedTypes
-                .derivedTypeBuilder(bitsTypeDefinition1, Q_NAME).build();
-        final DerivedBitsType derivedBitsType2 = (DerivedBitsType)DerivedTypes
-                .derivedTypeBuilder(bitsTypeDefinition2, Q_NAME).build();
+        final var derivedBitsType1 = assertInstanceOf(DerivedBitsType.class,
+            DerivedTypes.derivedTypeBuilder(bitsTypeDefinition1, Q_NAME).build());
+        final var derivedBitsType2 = assertInstanceOf(DerivedBitsType.class,
+            DerivedTypes.derivedTypeBuilder(bitsTypeDefinition2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedBitsType1, derivedBitsType2);
 
         restrictedBuilderTest(RestrictedTypes.newBitsBuilder(bitsTypeDefinition1, Q_NAME),
@@ -300,17 +286,17 @@ class TypeTest {
 
     @Test
     void enumerationTypeTest() {
-        final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
-            .build();
-        final BaseEnumerationType baseEnumerationType2 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
-            .build();
+        final var baseEnumerationType1 = assertInstanceOf(BaseEnumerationType.class,
+            BaseTypes.enumerationTypeBuilder(Q_NAME).build());
+        final var baseEnumerationType2 = assertInstanceOf(BaseEnumerationType.class,
+            BaseTypes.enumerationTypeBuilder(Q_NAME).build());
         hashCodeEqualsToStringTest(baseEnumerationType1, baseEnumerationType2);
         assertEquals(baseEnumerationType1.getValues(), baseEnumerationType2.getValues());
 
-        final DerivedEnumerationType derivedEnumerationType1 = (DerivedEnumerationType)DerivedTypes
-                .derivedTypeBuilder(baseEnumerationType1, Q_NAME).build();
-        final DerivedEnumerationType derivedEnumerationType2 = (DerivedEnumerationType)DerivedTypes
-                .derivedTypeBuilder(baseEnumerationType2, Q_NAME).build();
+        final var derivedEnumerationType1 = assertInstanceOf(DerivedEnumerationType.class,
+            DerivedTypes.derivedTypeBuilder(baseEnumerationType1, Q_NAME).build());
+        final var derivedEnumerationType2 = assertInstanceOf(DerivedEnumerationType.class,
+            DerivedTypes.derivedTypeBuilder(baseEnumerationType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedEnumerationType1, derivedEnumerationType2);
 
         restrictedBuilderTest(RestrictedTypes.newEnumerationBuilder(baseEnumerationType1, Q_NAME),
@@ -320,25 +306,25 @@ class TypeTest {
 
     @Test
     void leafrefTypeTest() {
-        final PathExpression expr = mock(PathExpression.class);
+        final var expr = mock(PathExpression.class);
 
-        final LeafrefTypeBuilder leafrefTypeBuilder1 = BaseTypes.leafrefTypeBuilder(Q_NAME);
-        final LeafrefTypeBuilder leafrefTypeBuilder2 = BaseTypes.leafrefTypeBuilder(Q_NAME);
+        final var leafrefTypeBuilder1 = BaseTypes.leafrefTypeBuilder(Q_NAME);
+        final var leafrefTypeBuilder2 = BaseTypes.leafrefTypeBuilder(Q_NAME);
         leafrefTypeBuilder1.setPathStatement(expr);
         leafrefTypeBuilder2.setPathStatement(expr);
-        final BaseLeafrefType baseLeafrefType1 = (BaseLeafrefType)leafrefTypeBuilder1.build();
-        final BaseLeafrefType baseLeafrefType2 = (BaseLeafrefType)leafrefTypeBuilder1.build();
+        final var baseLeafrefType1 = assertInstanceOf(BaseLeafrefType.class, leafrefTypeBuilder1.build());
+        final var baseLeafrefType2 = assertInstanceOf(BaseLeafrefType.class, leafrefTypeBuilder1.build());
         hashCodeEqualsToStringTest(baseLeafrefType1, baseLeafrefType2);
         assertEquals(expr, baseLeafrefType1.getPathStatement());
 
-        final DerivedLeafrefType derivedLeafrefType1 = (DerivedLeafrefType)DerivedTypes
-                .derivedTypeBuilder(baseLeafrefType1, Q_NAME).build();
-        final DerivedLeafrefType derivedLeafrefType2 = (DerivedLeafrefType)DerivedTypes
-                .derivedTypeBuilder(baseLeafrefType2, Q_NAME).build();
+        final var derivedLeafrefType1 = assertInstanceOf(DerivedLeafrefType.class,
+            DerivedTypes.derivedTypeBuilder(baseLeafrefType1, Q_NAME).build());
+        final var derivedLeafrefType2 = assertInstanceOf(DerivedLeafrefType.class,
+            DerivedTypes.derivedTypeBuilder(baseLeafrefType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedLeafrefType1, derivedLeafrefType2);
 
         restrictedBuilderTest(RestrictedTypes.newLeafrefBuilder(baseLeafrefType1, Q_NAME),
-                RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, Q_NAME));
+            RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, Q_NAME));
         concreteBuilderTest(baseLeafrefType1, derivedLeafrefType1);
     }
 
@@ -350,38 +336,38 @@ class TypeTest {
         final var baseDecimalType2 = assertInstanceOf(BaseDecimalType.class, BaseTypes.decimalTypeBuilder(Q_NAME)
                 .setFractionDigits(1)
                 .buildType());
-        final UnionTypeBuilder unionTypeBuilder1 = BaseTypes.unionTypeBuilder(Q_NAME);
-        final UnionTypeBuilder unionTypeBuilder2 = BaseTypes.unionTypeBuilder(Q_NAME);
+        final var unionTypeBuilder1 = BaseTypes.unionTypeBuilder(Q_NAME);
+        final var unionTypeBuilder2 = BaseTypes.unionTypeBuilder(Q_NAME);
         unionTypeBuilder1.addType(baseDecimalType1);
         unionTypeBuilder2.addType(baseDecimalType2);
-        final BaseUnionType baseUnionType1 = (BaseUnionType)unionTypeBuilder1.build();
-        final BaseUnionType baseUnionType2 = (BaseUnionType)unionTypeBuilder2.build();
+        final var baseUnionType1 = assertInstanceOf(BaseUnionType.class, unionTypeBuilder1.build());
+        final var baseUnionType2 = assertInstanceOf(BaseUnionType.class, unionTypeBuilder2.build());
         hashCodeEqualsToStringTest(baseUnionType1, baseUnionType2);
         assertEquals(baseUnionType1.getTypes(), baseUnionType2.getTypes());
 
-        final DerivedUnionType derivedUnionType1 = (DerivedUnionType)DerivedTypes
-                .derivedTypeBuilder(baseUnionType1, Q_NAME).build();
-        final DerivedUnionType derivedUnionType2 = (DerivedUnionType)DerivedTypes
-                .derivedTypeBuilder(baseUnionType2, Q_NAME).build();
+        final var derivedUnionType1 = assertInstanceOf(DerivedUnionType.class,
+            DerivedTypes.derivedTypeBuilder(baseUnionType1, Q_NAME).build());
+        final var derivedUnionType2 = assertInstanceOf(DerivedUnionType.class,
+            DerivedTypes.derivedTypeBuilder(baseUnionType2, Q_NAME).build());
         hashCodeEqualsToStringTest(derivedUnionType1, derivedUnionType2);
 
         restrictedBuilderTest(RestrictedTypes.newUnionBuilder(baseUnionType1, Q_NAME),
-                RestrictedTypes.newUnionBuilder(baseUnionType2, Q_NAME));
+            RestrictedTypes.newUnionBuilder(baseUnionType2, Q_NAME));
         concreteBuilderTest(baseUnionType1, derivedUnionType1);
     }
 
     @Test
     void abstractTypeDefinitionQnameTest() {
-        final AbstractTypeDefinition<?> abstractTypeDefinition = (AbstractTypeDefinition<?>)
-            BaseTypes.decimalTypeBuilder(Q_NAME).setFractionDigits(1).buildType();
+        final var abstractTypeDefinition = assertInstanceOf(AbstractTypeDefinition.class,
+            BaseTypes.decimalTypeBuilder(Q_NAME).setFractionDigits(1).buildType());
         assertEquals(Q_NAME, abstractTypeDefinition.getQName());
     }
 
     @Test
     void abstractDerivedTypeTest() {
-        final BaseBinaryType baseBinaryType1 = BaseBinaryType.INSTANCE;
-        final AbstractDerivedType<?> abstractDerivedType = (AbstractDerivedType<?>)
-            DerivedTypes.derivedTypeBuilder(baseBinaryType1, Q_NAME).build();
+        final var baseBinaryType1 = BaseBinaryType.INSTANCE;
+        final var abstractDerivedType = assertInstanceOf(AbstractDerivedType.class,
+            DerivedTypes.derivedTypeBuilder(baseBinaryType1, Q_NAME).build());
         assertEquals(Optional.empty(), abstractDerivedType.getDescription());
         assertEquals(Optional.empty(), abstractDerivedType.getReference());
         assertEquals(Status.CURRENT, abstractDerivedType.getStatus());
@@ -389,45 +375,42 @@ class TypeTest {
 
     @Test
     void concreteTypeBuilderBuildTest() {
-        final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)
-            BaseTypes.enumerationTypeBuilder(Q_NAME).build();
-        final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(
-                baseEnumerationType1, Q_NAME);
-        final TypeDefinition<?> typeDefinition = concreteTypeBuilder.build();
+        final var baseEnumerationType1 = assertInstanceOf(BaseEnumerationType.class,
+            BaseTypes.enumerationTypeBuilder(Q_NAME).build());
+        final var concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseEnumerationType1, Q_NAME);
+        final var typeDefinition = concreteTypeBuilder.build();
         assertNotNull(typeDefinition);
     }
 
     @Test
     void constraintTypeBuilderTest() throws InvalidLengthConstraintException {
-        final BaseBinaryType baseBinaryType = (BaseBinaryType)BaseTypes.binaryType();
-        final LengthRestrictedTypeBuilder<?> lengthRestrictedTypeBuilder = RestrictedTypes
-                .newBinaryBuilder(baseBinaryType, Q_NAME);
+        final var baseBinaryType = assertInstanceOf(BaseBinaryType.class, BaseTypes.binaryType());
+        final var lengthRestrictedTypeBuilder = RestrictedTypes.newBinaryBuilder(baseBinaryType, Q_NAME);
         final Long min = (long) 0;
-        final UnresolvedNumber max = UnresolvedNumber.max();
-        final List<ValueRange> lengthArrayList = List.of(ValueRange.of(min, max));
+        final var max = UnresolvedNumber.max();
+        final var lengthArrayList = List.of(ValueRange.of(min, max));
         lengthRestrictedTypeBuilder.setLengthConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
-        final TypeDefinition<?> typeDefinition = lengthRestrictedTypeBuilder.buildType();
+        final var typeDefinition = lengthRestrictedTypeBuilder.buildType();
         assertNotNull(typeDefinition);
 
-        final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
-        final RangeRestrictedTypeBuilder<?, ?> rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(
-            integerTypeDefinition8, Q_NAME);
+        final var integerTypeDefinition8 = BaseTypes.int8Type();
+        final var rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(integerTypeDefinition8, Q_NAME);
         rangeRestrictedTypeBuilder.setRangeConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
-        final TypeDefinition<?> typeDefinition1 = rangeRestrictedTypeBuilder.buildType();
+        final var typeDefinition1 = rangeRestrictedTypeBuilder.buildType();
         assertNotNull(typeDefinition1);
     }
 
     @Test
     void exceptionTest() {
-        final EnumPair enumPair = EnumPairBuilder.create("enum1", 1).setDescription("description")
+        final var enumPair = EnumPairBuilder.create("enum1", 1).setDescription("description")
                 .setReference("reference").setUnknownSchemaNodes(mock(UnknownSchemaNode.class)).build();
 
-        final RangeSet<Integer> rangeset = ImmutableRangeSet.of(Range.closed(1, 2));
-        final InvalidRangeConstraintException invalidRangeConstraintException = new InvalidRangeConstraintException(
+        final var rangeset = ImmutableRangeSet.of(Range.closed(1, 2));
+        final var invalidRangeConstraintException = new InvalidRangeConstraintException(
                 rangeset, "error msg", "other important messages");
         assertSame(rangeset, invalidRangeConstraintException.getOffendingRanges());
 
-        final InvalidBitDefinitionException invalidBitDefinitionException = new InvalidBitDefinitionException(
+        final var invalidBitDefinitionException = new InvalidBitDefinitionException(
                 BIT_A, "error msg", "other important messages");
         assertEquals(BIT_A, invalidBitDefinitionException.getOffendingBit());
 
@@ -438,13 +421,13 @@ class TypeTest {
 
     @Test
     void identityrefTypeBuilderException() {
-        final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(Q_NAME);
+        final var builder = BaseTypes.identityrefTypeBuilder(Q_NAME);
         assertThrows(IllegalStateException.class, () -> builder.build());
     }
 
     @Test
     void invalidBitDefinitionExceptionTest() {
-        final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME)
+        final var bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME)
                 .addBit(BIT_A)
                 .addBit(BitBuilder.create("test-name-1", Uint32.valueOf(55)).build());
 
@@ -453,12 +436,12 @@ class TypeTest {
 
     @Test
     void invalidEnumDefinitionExceptionTest() {
-        final UnknownSchemaNode unknown = mock(UnknownSchemaNode.class);
-        final EnumPair enumPair1 = EnumPairBuilder.create("enum1", 1).setDescription("description")
+        final var unknown = mock(UnknownSchemaNode.class);
+        final var enumPair1 = EnumPairBuilder.create("enum1", 1).setDescription("description")
                 .setReference("reference").setUnknownSchemaNodes(unknown).build();
-        final EnumPair enumPair2 = EnumPairBuilder.create("enum", 1).setDescription("description")
+        final var enumPair2 = EnumPairBuilder.create("enum", 1).setDescription("description")
                 .setReference("reference").setUnknownSchemaNodes(unknown).build();
-        final EnumerationTypeBuilder enumerationTypeBuilder = BaseTypes.enumerationTypeBuilder(Q_NAME);
+        final var enumerationTypeBuilder = BaseTypes.enumerationTypeBuilder(Q_NAME);
         enumerationTypeBuilder.addEnum(enumPair1);
         enumerationTypeBuilder.addEnum(enumPair2);
 
@@ -476,15 +459,15 @@ class TypeTest {
     }
 
     private static void restrictedBuilderTest(final TypeBuilder<?> typeBuilder1, final TypeBuilder<?> typeBuilder2) {
-        final TypeDefinition<?> typeDefinition1 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder1).buildType();
-        final TypeDefinition<?> typeDefinition2 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder2).buildType();
+        final var typeDefinition1 = assertInstanceOf(AbstractRestrictedTypeBuilder.class, typeBuilder1).buildType();
+        final var typeDefinition2 = assertInstanceOf(AbstractRestrictedTypeBuilder.class, typeBuilder2).buildType();
         hashCodeEqualsToStringTest(typeDefinition1, typeDefinition2);
     }
 
     private static void concreteBuilderTest(final TypeDefinition<?> baseTypeDef,
             final TypeDefinition<?> derivedTypeDef) {
-        final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseTypeDef, Q_NAME);
-        final TypeDefinition<?> typeDefinition = concreteTypeBuilder.buildType();
+        final var concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseTypeDef, Q_NAME);
+        final var typeDefinition = concreteTypeBuilder.buildType();
         assertEquals(typeDefinition.getBaseType(), derivedTypeDef.getBaseType());
     }
 }